java - 是否有与 java.lang.Number 等效的 C++？

Question

我正在尝试创建一个 std::vector在 C++ 中可以接受任何类型的数字数据类型(char、short、int、long、float 和 double)。

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

在 C++ 中是否有等效项(最好是 <=C++03)。如果不是，实现这一目标的最佳方法是什么？

PS - 我真的不想为每种数据类型使用一个 vector :/

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;

你可以避免使用 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 (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 个简单的解决方案(恕我直言):

• 如果你真的想节省内存，你必须为每种类型使用一个 vector 。
• 或者使用union

PS:你也可以看看像boost::any这样的第三方库。 .