Plantillas de covariantes de C++

Question

Creo que se me ha preguntado antes, pero no puedo encontrarlo en SO, ni puedo encontrar nada útil en Google. Tal vez "covariante" no es la palabra que estoy buscando, pero este concepto es muy similar a los tipos de retorno covariante en las funciones, por lo que creo que es probablemente correcto. Esto es lo que quiero hacer y me da un error del compilador:

class Base; 
class Derived : public Base; 

SmartPtr<Derived> d = new Derived; 
SmartPtr<Base> b = d; // compiler error 

Asumir esas clases se plasmen plenamente ... Creo que se entiende la idea. No puede convertir un SmartPtr<Derived> en un SmartPtr<Base> por algún motivo poco claro. Recuerdo que esto es normal en C++ y en muchos otros idiomas, aunque por el momento no puedo recordar por qué.

Mi pregunta de raíz es: ¿cuál es la mejor manera de realizar esta operación de asignación? Actualmente, estoy sacando el puntero del SmartPtr, actualizándolo explícitamente al tipo base, y luego envolviéndolo en un nuevo SmartPtr del tipo apropiado (tenga en cuenta que esto no está filtrando recursos porque nuestra clase de SmartPtr de fabricación propia utiliza una referencia intrusiva contando). Eso es largo y desordenado, especialmente cuando necesito envolver el SmartPtr en otro objeto ... ¿cualquier atajo?

Answer 1

Tanto el constructor de copia como el operador de asignación deberían poder tomar un SmartPtr de un tipo diferente e intentar copiar el puntero de uno a otro. Si los tipos no son compatibles, el compilador se quejará, y si son compatibles, habrá resuelto su problema. Algo como esto:

template<class Type> class SmartPtr 
{ 
    .... 
    template<class OtherType> SmartPtr(const SmartPtr<OtherType> &blah) // same logic as the SmartPtr<Type> copy constructor 

    template<class OtherType> SmartPtr<Type> &operator=(const SmartPtr<OtherType> &blah) // same logic as the SmartPtr<Type> assignment operator 
}; 

Answer 2

Depende de la clase SmartPtr. Si tiene un constructor de copia (o en su caso, operador de asignación) que toma SmartPtr<T>, donde T es el tipo con el que se construyó, entonces no va a funcionar, porque SmartPtr<T1> no está relacionado con SmartPtr<T2> incluso si T1 y T2 son relacionado por herencia.

Sin embargo, si SmartPtr tiene un operador de constructor de copia/asignación a plantillas, con parámetro de plantilla TOther, que acepta SmartPtr<TOther>, entonces debería funcionar.

Answer 3

Asumiendo que tiene el control de la clase SmartPtr, la solución es proporcionar un constructor de plantilla:

template <class T> 
class SmartPtr 
{ 
    T *ptr; 
public: 

    // Note that this IS NOT a copy constructor, just another constructor that takes 
    // a similar looking class. 
    template <class O> 
    SmartPtr(const SmartPtr<O> &src) 
    { 
     ptr = src.GetPtr(); 
    } 
    // And likewise with assignment operator. 
}; 

Si los tipos T y S son compatibles, funcionará, si ellos no son obtendrás un error de compilación.

Answer 4

SmartPtr<Base> y SmartPtr<Derived> son dos ejemplos distintos de una plantilla de SmartPtr. Estas nuevas clases no comparten la herencia que Base y Derived hacen. Por lo tanto, tu problema.

what is the best way to perform this assignment operation?

SmartPtr<Base> b = d; 

no invoca operador de asignación. Esto invoca la copia-ctor (la copia se elide en la mayoría de los casos) y es exactamente como si escribió:

SmartPtr<Base> b(d); 

Proporcionar una copia-ctor que toma un SmartPtr<OtherType> y ponerlo en práctica. Lo mismo aplica para el operador de asignación. Tendrá que escribir el copy-ctor y op = teniendo en cuenta la semántica de SmartPtr.

Answer 5

Las plantillas no son covariantes, y eso es bueno; Imaginemos lo que sucedería en el caso siguiente:

vector<Apple*> va; 
va.push_back(new Apple); 

// Now, if templates were covariants, a vector<Apple*> could be 
// cast to a vector<Fruit*> 
vector<Fruit*> & vf = va; 
vf.push_back(new Orange); // Bam, we just added an Orange among the Apples! 

para lograr lo que estamos tratando de hacer, la clase SmartPointer debe tener un constructor a plantillas, que se lleva a cualquiera otra SmartPointer o un puntero de otro tipo. Puedes echar un vistazo a boost :: shared_ptr, que hace exactamente eso.

template <typename T> 
class SmartPointer { 

    T * ptr; 

    public: 
    SmartPointer(T * p) : ptr(p) {} 
    SmartPointer(const SmartPointer & sp) : ptr(sp.ptr) {} 

    template <typename U> 
    SmartPointer(U * p) : ptr(p) {} 

    template <typename U> 
    SmartPointer(const SmartPointer<U> & sp) : ptr(sp.ptr) {} 

    // Do the same for operator= (even though it's not used in your example) 
}; 

Answer 6

Creo que lo más fácil es para proporcionar la conversión automática a otro SmartPtr de acuerdo a lo siguiente:

template <class T> 
class SmartPtr 
{ 
public: 
    SmartPtr(T *ptr) { t = ptr; } 
    operator T *() const { return t; } 
    template <class Q> operator SmartPtr<Q>() const 
    { return SmartPtr<Q>(static_cast<Q *>(static_cast<T *>(* this))); } 
private: 
    T *t; 
}; 

Tenga en cuenta que esta aplicación es robusto en el sentido de que la plantilla operador de conversión no necesita conocer la semántica del puntero inteligente, por lo que el recuento de referencias no necesita replicarse, etc.