Question

我正在尝试创建一个std::vector，它可以在C ++中接受任何类型的数值数据类型（char，short，int，long，float和double）。

在java中，我可以创建List<Number> list = ArrayList<Number>();

C ++中是否有等价物（最好是＆lt; = C ++ 03）。如果没有，实现这一目标的最佳方法是什么？

PS - 我真的不希望每种数据类型都有一个向量：/

Answer 1

您想要的简单方法是：

enum datatype
{
    dt_none,
    dt_char,
    dt_uchar,
    dt_short,
    dt_ushort,
    dt_long,
    dt_ulong,
    dt_float,
    dt_double
};

struct Any
{
      datatype type; // To know what is stored inside union, not mandatory if you know that in another way
      union
      {
          char vchar;
          unsigned char vuchar;
          short vshort;
          unsigned short vushort;
          long vlong;
          unsigned long vulong;
          float vfloat;
          double vdouble;
      } data;
};

std::vector<Any> mydata;

您可以避免使用联合，但它需要更多内存（每个值的指针+实际大小）并且使用起来更复杂：

struct Any
{
     private:
         void * data;
         datatype type;

     public:
         Any():
             data(NULL),
             type(dt_none)
         {}

         ~Any()
         {
             deleteData();  
         }

         void deleteData()
         {
             // Because deleting a void * is UB, we have to check real datatype
             if (data != NULL)
             {
                 if (type == dt_char)
                     delete static_cast<char *>(data);
                 if (type == dt_uchar)
                     delete static_cast<unsigned char *>(data);
                 ....
             }   
         }

         datatype getType() const
         {
             return type;
         }

         void setChar(char v)
         {
             deleteData(); 
             data = new char(v);
             type = dt_char;
         } 


         char toChar() const
         {
             return *static_cast<char *>(data);
         } 

         .....

         void setDouble(double v)
         {
             deleteData();
             data = new double(v);
         }

         double toDouble() const
         {
             return *static_cast<double*>(data);
         }
};

一种可能的优化，是使用指针存储小型数据，以节省一些字节（但要小心！）。但是如果你存储了很多大型数据，union仍然会更好。此外，指针的大小取决于平台，因此很难选择哪种类型可以直接存储在指针中并具有可移植代码。此外，在64位计算机上，指针的大小为8个字节，这也是double的常见大小（因此，在这种情况下，直接存储指针内的每个类型，这与union的内存消耗相同但是以一种非常复杂和不安全的方式）：

struct Any
{
     private:
         void * data;
         datatype type;

     public:
         Any():
             data(NULL),
             type(dt_none)
         {}

         ~Any()
         {
             deleteData();
         }

         void deleteData()
         {
             // Because deleting a void * is UB, we have to check real datatype
             if (type != dt_char && type != dt_uchar && data != NULL)
             {
                 if (type == dt_double)
                     delete static_cast<double *>(data);
                 ....
             } 
             data = NULL;
         }

         datatype getType() const
         {
             return type;
         }

         void setChar(char v)
         {
             data = reinterpret_cast<void *>(v);
         } 


         char toChar() const
         {
             return static_cast<char>(reinterpret_cast<intptr_t>(data));
         } 

         .....

         void setDouble(double v)
         {
             deleteData();
             data = new double(v);
         }

         double toDouble() const
         {
             return *static_cast<double*>(data);
         }
};

所有这些说你只有2个简单的解决方案（恕我直言）：

如果你真的想节省内存，你必须使用每种类型的矢量。
或使用union

PS：您还可以查看第三方库，例如boost::any。

是否有java.lang.Number的C ++等价物？

1 个答案: