Plantillas C++ con objetos de interfaz

Question

Tengo el siguiente código que no se compila.

class Base { 
    public: 
     virtual ~Base() { }; 
}; 

class Derived : public Base { }; 

class NotDerived { }; 

template <typename T> 
class Group { }; 

int main() { 
    Group<Base> *g = NULL; 

    g = new Group<Base>();  // Works 
    g = new Group<Derived>(); // Error, but I want it to work 

    g = new Group<NotDerived>(); // Error, as expected 
} 

entiendo que esto no va a compilar porque g es un tipo diferente de Group<Derived>. Para que esto funcione en Java, haría algo como Group<? extends Base> g, pero C++ no tiene esa palabra clave hasta donde yo sé. ¿Qué se puede hacer?

Editar: Me gustaría aclarar que no quiero que sea posible establecer tipos no derivados de Base como g. He actualizado mi ejemplo para explicar esto.

Editar 2: Hay dos soluciones a mi problema. Dave's Me pareció simple y fácil de definir. Pero Bowie's (junto con Mark's adiciones) satisfizo mis necesidades mejor.

Answer 1

usted podría hacer Grupo < Base> una clase base de todos Grupo < T> T! = Base.

class Base { 
    public: 
     virtual ~Base() { }; 
}; 

class Derived : public Base { }; 


template <typename T> class Group; 

struct Empty { }; 

template <typename T> 
struct base_for_group_t { 
    typedef Group<Base> type; 
}; 

template <> 
struct base_for_group_t<Base> { 
    typedef Empty type; 
}; 

template <typename T> 
class Group : public base_for_group_t<T>::type { }; 

int main() { 
    Group<Base> *g = 0; 

    g = new Group<Base>(); // Works 
    g = new Group<Derived>(); // now works 
} 

Answer 2

No creo que C++ apoye eso. La plantilla C++ se maneja completamente en tiempo de compilación, por lo que no es compatible con polimorfismo. Eso significa que el tipo de argumentos de la plantilla debe ser exactamente el mismo para ambos lados de la expresión de asignación.

Answer 3

Las plantillas C++ y los genéricos de Java son muy muy diferentes, como un cuadrado y un círculo. uno genera código, el otro verifica que en tiempo de ejecución los tipos trabajarán y coincidirán en un bloque de código genérico. en pocas palabras.

What are the differences between "generic" types in C++ and Java?

Answer 4

Las clases Group<Base> y Group<Derived> son clases sin relación alguna, diferentes. Los indicadores para ellos no son convertibles en ninguna dirección.

Si necesitas comportamiento de ejecución polimórfica, su plantilla de clase Group podría derivar de un (no moldeado) clase base común:

class Group // base 
{ 
    virtual ~Group() { } 
}; 

template <typename T> 
class ConcreteGroup : public Group 
{ 
    // ... 
    T * m_impl; 
}; 

Group * g1 = new ConcreteGroup<A>; 
Group * g1 = new ConcreteGroup<B>; 

Answer 5

Bowie Owens's Answer maneja la covarianza que necesita para resolver la pregunta original. En cuanto a la restricción que solicitó en la pregunta editada, puede lograrlo mediante el uso de rasgos de tipo.

template <typename T, class Enable = void> class Group; 

template <typename T> 
class Group<T, typename enable_if<is_base_of<Base, T>::value>::type> 
    : public base_for_group_t<T>::type { }; 

Answer 6

Creo que entiendo lo que está buscando. No estoy seguro de que sea el mejor enfoque (y es posible que desee consultar Boost.Factory).

template <class T> 
class Factory { 

public: 
    virtual T* operator()() = 0; 
}; 

template <class Derived, class Base> 
class ConcreteFactory : public Factory<Base> { 

public: 
    virtual Base* operator()() { 
    return new Derived(); 
    } 
}; 

class Base { 
public: 
    virtual ~Base() {}; 
}; 

class Derived1 : public Base { }; 
class Derived2: public Base {}; 

class NotDerived {}; 

int main() 
{ 
    Factory<Base>* g; 

    g = new ConcreteFactory<Derived1, Base>; 
    g = new ConcreteFactory<Derived2, Base>; 
    // g = new ConcreteFactory<NotDerived, Base>; // Will not work if you try to do this 
}