plantilla dinámica de instancias

Question

Tengo una plantilla de clase, y tengo que declarar un objeto de esa clase, sin definir los parámetros de tipo, de modo que pueda definirlos condicional después, por ejemplo:

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

Bueno , ciertamente no puedes hacer eso. Vas a tener que hacer una derivación de otra clase, por ejemplo:

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

La forma más sencilla de hacerlo es utilizar otra función.

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)); 
} 

Esto mantiene toda la información del tipo y no depende de la herencia. La desventaja de la herencia es que T no puede aparecer en ninguna interfaz de función, pero con esta situación sí puede.

Answer 3

plantillas se expanden en tiempo de compilación, por lo que su problema es realmente lo mismo que la siguiente:

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); 
} 

Con suerte si viste el código anterior, se podría pensar (así como "tal vez debería usar plantillas ")" Voy a necesitar una clase base común para esto, o bien voy a refactor ".

Cuando genera los dos tipos en tiempo de compilación utilizando una plantilla de clase, esta conclusión es la misma.

• Recomendaría la refactorización, buscando una solución como DeadMG's; ¡crear una jerarquía de herencia solo para solucionar un problema de flujo lógico del programa es programar hacia atrás!

Answer 4

Puede utilizar puntero nulo, mientras que crear el objeto de la clase A
Mira siguiente ejemplo de código:

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;  
    } 
}