Question

我有一个类模板，我需要声明该类的对象，而不定义类型参数，以便我可以稍后有条件地定义它们，例如：

template<typename T>
class A{
public:
    A(T v){var = v};
    ~A(){};

    T var;
}

int main(){
    A<>* object; // Or sometihng along these lines...?
    if(/* something*/)
        object = new A<float>(0.2f);
    else{
        object = new A<int>(3);
    }
}

Answer 1

嗯，你当然不能那样做。你必须使A派生自另一个类，例如：

template<typename T>
class A : public B {
public:
    A(T v){var = v};
    ~A(){};

    T var;
}

int main(){
    B* object;
    if(/* something*/)
        object = new A<float>(0.2f);
    else{
        object = new A<int>(3);
    }
}

Answer 2

最简单的方法是使用其他功能。

template<typename T> void other_stuff(A<T>* object) {
    // use T here
}
int main() {
    if (condition)
        other_stuff(new A<float>(0.2f));
    else
        other_stuff(new A<int>(3));
}

这维护所有类型信息，不依赖于继承。继承的缺点是T不能出现在任何函数接口中，但在这种情况下它可以。

Answer 3

模板在编译时扩展，因此您的问题实际上与以下内容完全相同：

struct A_float {            // struct is easier when everything's public
    A(float v) : var(v) {}  // (use the ctor-initializer please!)
    ~A() {}

    float var;
};                          // don't forget the semicolon

struct A_int {
    A(int v) : var(v) {}
    ~A() {}

    int var;
};

int main() {
    WhatType* object; // What type here?
    if (/* something*/)
        object = new A_float(0.2f);
    else
        object = new A_int(3);
}

希望如果您看到上面的代码，您会想到（以及“也许我应该使用模板”）“我将需要一个公共基类，或者我将重构“。

使用类模板在编译时生成这两种类型时，这个结论是一样的。

我建议重构，寻找像Puppy's这样的解决方案;创建一个继承层次结构只是为了解决程序逻辑流程的缺陷就是向后编程！

Answer 4

您可以在创建A类对象时使用void指针。查看以下代码示例：

template<typename T>
class A
{
 public:
    A(T v){var = v;};
    A(){};
    ~A(){};
    T var;
};
int main(){
    A<void *> object; 
    if(1){ // do this
        object = new A<float>(0.31f);
        // type cast void pointer to get value
        cout<<*(float*)object.var;    
    }
    else{ // else do this
        object = new A<int>(34);
        // type cast void pointer to get value
        cout<<*(int*)object.var;    
    }
}

动态模板实例化

4 个答案: