Question

我的问题是关于动态更改/设置类型的定义检查变量值，该变量值可以在运行时更改，如下所示：

void changeMode(int mode)
{
    if(mode == 1)
    {
            typedef MyType float;
    }
    else if(mode == 2)
    {
            typedef MyType double;
    }
}

int main(int argc, char *argv[])
{
    MyType (2);
    MyType A = 3;
    MyType B = 2;
    MyType C = A + B;

    return 0;
}

有可能吗？这是模板的经典案例？可以避免使用模板吗？我的目标是集中类型定义，以便可以在运行时切换，而无需将其扩展到每个类或为将使用给定类型的每个类/函数使用“模板”。

Answer 1

typedef在编译时进行评估，所以没有。

但你可以使用prepocessor做这样的事情：

#ifdef TYPE_FLOAT
   typedef float Type;
#else
   typedef int Type;
#endif

但请记住它是在编译时

Answer 2

您可以将类型相关代码提取到函数模板（或更复杂情况下的类模板）：

template <typename MyType>
void ExecuteTypeDependentCode()
{
    MyType A = 3;
    MyType B = 2;
    MyType C = A + B;
}

然后你可以编写包装器，它的任务是在模式之间切换：

enum Modes
{
    FloatMode = 1,
    DoubleMode = 2
};

void ExecuteTypeDependentCode(Modes mode)
{
    switch (mode)
    {
        case FloatMode:
            ExecuteTypeDependentCode<float>();
            break;

        case DoubleMode:
            ExecuteTypeDependentCode<double>();
            break;
    }
}

使用示例：

int main(int argc, char *argv[])
{
    ExecuteTypeDependentCode(DoubleMode);

    return 0;
}

切换过程只能写一次（我描述了这种方法here）。

Answer 3

Typedef是静态评估的，所以你需要做一些类似于“模板经典案例”的事情（无论是什么：））

template <int Mode>
struct Dispatch { };

template <>
struct Dispatch <0> {
    using U = int; // fancy way of saying typedef
};

template <>
struct Dispatch <1> {
    using U = char; // feel free to use typedef
};

int main() {
    Dispatch<0>::U x; // compile time constant in <> (zero)
    x = 5;
    Dispatch<1>::U y; // compile time constant in <> (one)
    y = 'c';
}

Answer 4

正如其他答案所指出的那样，这不可能通过typedef实现。但是，您可以使用多态包装类来模拟此行为：

#include <cstdio>


class Gen
{
public:
    static int mode;

    static Gen* get()
    {
        switch(mode)
        {
        case 1:
            return new GenFloat();
        case 2:
            return new GenDouble();
        }

        return NULL;
    }
};

int Gen::mode = 0;

class DoubleGen : public Gen
{
public:
    DoubleGen() : d(0) {}
    DoubleGen(double val) : d(val) {}

    double d;
};

class FloatGen : public Gen
{
public:
    FloatGen() : f(0) {}
    FloatGen(float val) : f(val) {}

    float f;
};




int main(void)
{
    Gen::mode = 1;

    Gen* _float = gen::get();

    gen::mode = 2;

    Gen* _double = gen::get();

    delete _float;
    delete _double;

    return 0;
}

运行时类型定义

4 个答案: