C++ 在C++；

我希望能够做到以下几点：

我有一个包含数据类型的字符串数组：

string DataTypeValues[20] = {"char", "unsigned char", "short", "int"};

然后，我想在运行时创建一个数据类型的变量。我在编译时不知道正确的数据类型应该是什么

例如，如果在运行时我确定变量x的类型为int：

DataTypeValues[3] x = 100;

---

<>这显然不起作用，那么我该怎么做呢？

< P>简单的答案是，在C++编译时，不需要知道类型。您可以使用boost:：any或unions之类的工具来做类似的事情，但它不会很漂亮。

您不能。这种运行时元编程在C++中不被支持。

你唯一能做的就是手动循环类型并比较每个单独的类型。这里还可以使用factory对象，但这会涉及堆。

您必须使用联合来实现类似的功能，但处理联合是一件非常困难的事情，因此，你应该选择一个容器类，它封装了一个接口后面的联合逻辑，或者QTS

< P>每个人都说你不能在C++中这样做，所以缺少一个明显的解决方案。这是您可以使用基类的地方，您需要在那里定义常用接口，然后所有派生类都是您需要的任何类型。把它放在一个适合容器的智能指针中，就这样了。如果不能在基类中放入足够的接口，则可能必须使用动态类型推断，基类总是不受欢迎，因为它很难看，但它的存在是有原因的。动态分配您的类型可能不是最有效的事情，但一如既往，这取决于您使用它的目的。

我认为您确实在寻找一种动态类型语言。如果你必须坚持C++，嵌入一个解释器！p> 或者，您可以使用接口实现类似于组件模型的东西来处理包装的数据。从宇宙基类-IOObject开始，然后实现IInteger、IDouble、IString等的接口。对象本身将由工厂创建

---

或者你可以在工厂里使用空缓冲区。。。这是在C/C++中避免静态类型的古老方法（不使用基于继承的多态性）。然后加入大量的重新解释转换。

Visual Basic的“变体”数据类型就是您所说的。它可以保存任何内容、主要数据类型、数组、对象等

OLE Automation中的集合类可以存储不同数据类型的项。由于在编译时无法知道这些项的数据类型，因此向集合中添加项和从集合中检索项的方法使用变量。如果在Visual Basic中使用For Each构造，则迭代器变量必须是对象类型或变量--从

---

上面的页面给出了一些关于如何使用变量的见解，它展示了OLE如何在C++中处理变量。

最接近的是模板：

template<int i> class Data { };
template<> class Data<0> { typedef char type; }
template<> class Data<1> { typedef unsigned char type; }
template<> class Data<2 { typedef short type; }
template<> class Data<3> { typedef int type; }
Data<3>::Type x;

模板类数据{}；
模板类数据{typedef char type；}
模板类数据{typedef unsigned char type；}
模板类数据在您的简单示例中，不简单地使用列表中最宽的类型作为泛型容器，并在必要时转换为较小的类型（甚至依赖隐式转换），几乎没有什么好处

您可以对联合、类、多态性、RTTI、Boost变体等进行详细说明，但仅针对不同宽度的整数列表，这几乎不值得付出努力

在我看来，你似乎有一个意识到的问题，你已经发明了一个不切实际的解决方案，你现在正在寻求帮助。你最好描述你原来的问题，而不是把你的解决方案变成问题
 另外，不要忘记所有必须在这种神秘数据类型上运行的函数。大多数函数设计为仅使用一种类型，例如加法。函数重载以处理其他类型

您如何在运行时知道变量类型是什么？
现在想到的唯一方法是旧的C样式，其中使用了指向void的指针，如：

void *unkown;

Leter on您可以将任何对象指定给它，如下所示：

unkown = (void *)new int(4);

if(type==0) { // int 
    printf("%d\n", * ((int*)unkown) );
} else {
    // other type
}

如果您知道运行时中的类型，则可以对此类变量运行指定函数，如下所示：

unkown = (void *)new int(4);

if(type==0) { // int 
    printf("%d\n", * ((int*)unkown) );
} else {
    // other type
}

例如，当使用malloc[，等]函数时，使用这种方式（铸造空隙*）

当C++现在更发达时，我并不是说这是一个很好的练习。
仍然同意有人说这不是解决你问题的最好办法。但也许经过一些重新设计后，你会发现它很有用

您可能会发现，自C++11以来，自动类型也很有趣。
我想这个答复可能要晚几年。但对于可能碰巧看到此线程的人来说，一个可能的解决方案是使用变量模板。例如：

template<typename T>
T var;

template<typename T>
T arr[10]; 

int main() {
    int temp;
    var<int> = 2;
    cout << var<int> << ' '; // this would output 2
    var<char> = 'a';
    cout << var<int> << ' '; // var<int> value would be a space character
    cout << var<char> << ' '; // this would output 'a'
    for(int i = 0; i < 10; i++) {
        switch(i % 2) {
            case 0:
                arr<int>[i] = ++temp;
                break;
            case 1:
                arr<char>[i] = 'a' + ++temp;
                break;
    }
    cout << endl;
    for(int i = 0; i < 10; i++) {
        switch(i % 2) {
            case 0:
                cout << arr<int>[i] << ' ';
                break;
            case 1:
                cout << arr<char>[i] << ' ';
                break;
        }
    }
    return 0;
}

模板
T-var；
模板
T-arr[10]；
int main（）{
内部温度；
var=2；
不能使用union并创建自己的动态类。
伪代码如下所示：

union all{
    char c;
    unsigned char uc; 
    short s; 
    int i;
}; 

class dynamic{ 
    public:
        char Type; 
        all x; 

        template <class T> 
        dynamic(T y){ 
            int Int;
            char Char;
            unsigned char Uchar;
            short Short;
            if (typeof(y) == typeof(Char)){
                Type = 1;
            }else if (typeof(y) == typeof(Uchar)) {
                Type = 2; 
            }else if (typeof(y) == typeof(Short)) {
                Type = 3;
            }else{
                Type = 4;
            } 

            switch (Type) {
                case 1: x.c = y; break;
                case 2: x.uc = y; break;
                case 3: x.s = y; break ;
                case 4: x.i = y; break ; 
            }
        } 

        auto get() {
            switch(Type) {
                case 1: return x.c; 
                case 2: return x.uc; 
                case 3: return x.s; 
                case 4: retuen x.i; 
            }
        }  

    //also make the operators function you like to use
} ;

union all{
字符c；
无符号字符uc；
短s；
int i；
}; 
类动态{
公众：
煤焦类型；
全部x；
模板
动态（Ty）{
int-int；
半焦；
无符号字符；
短小；
if（typeof（y）=typeof（Char））{
类型=1；
}else if（typeof（y）=typeof（Uchar））{
类型=2；
}else if（typeof（y）=typeof（Short））{
类型=3；
}否则{
类型=4；
} 
开关（类型）{
案例1:x.c=y；断裂；
案例2:x.uc=y；断裂；
案例3:x.s=y；断裂；
案例4:x.i=y；断裂；
}
} 
自动获取（）{
开关（类型）{
案例1：retur