¿Cómo es que un puntero a una clase derivada no se puede pasar a una función esperando una referencia a un puntero a la clase base?

Question

Perdón por el título largo pero quería ser específico. me espera el siguiente código para trabajar pero no y no puedo entender por qué:/

#include <cstdio> 
#include <cassert> 

class UniquePointer 
{ 
public: 
    void Dispose() 
    { 
     delete this; 
    } 

    friend void SafeDispose(UniquePointer*& p) 
    { 
     if (p != NULL) 
     { 
      p->Dispose(); 
      p = NULL; 
     } 
    } 
protected: 
    UniquePointer() { } 
    UniquePointer(const UniquePointer&) { } 
    virtual ~UniquePointer() { } 
}; 

class Building : public UniquePointer 
{ 
public: 
    Building() 
    : mType(0) 
    {} 
    void SetBuildingType(int type) { mType = type; } 
    int GetBuildingType() const { return mType; } 
protected: 
    virtual ~Building() { } 
    int mType; 
}; 

void Foo() 
{ 
    Building* b = new Building(); 
    b->SetBuildingType(5); 
    int a = b->GetBuildingType(); 
    SafeDispose(b);  // error C2664: 'SafeDispose' : cannot convert parameter 1 from 'Building *' to 'UniquePointer *&' 
    b->Dispose(); 
} 

int main(int argc, char* argv[]) 
{ 
    Foo(); 
    return 0; 
} 

Answer 1

Imagínese fuera legal. Posteriormente, se podría escribir código como este:

class Animal : public UniquePointer 
{ 
}; 

void Transmogrify(UniquePointer*& p) 
{ 
    p = new Animal(); 
} 

void Foo() 
{ 
    Building* b = nullptr; 
    Transmogrify(b); 
    b->SetBuildingType(0); // crash 
} 

Observe que usted ha violado el sistema de tipos (pones un animal que un edificio debe ser) sin necesidad de un yeso o elevar un error de compilación.

Answer 2

No está permitido porque si fuera usted podría hacer lo siguiente:

friend void SafeDispose(UniquePointer*& p) 
{ 
    p = new UniquePointer(); 
} 


Building* building; 
SafeDispose(building) 
//building points to a UniquePointer not a Building. 

supongo que el trabajo en torno a que sería una función de plantilla.

Answer 3

No creo que sea posible hacerlo funcionar de la manera que lo tiene diseñado. En su lugar, intente lo siguiente:

template <typename T> 
void SafeDispose(T * & p) 
{ 
    if (p != NULL) 
    { 
     p->Dispose(); 
     p = NULL; 
    } 
} 

class UniquePointer 
{ 
public: 
    void Dispose() 
    { 
     delete this; 
    } 

protected: 
    UniquePointer() { } 
    UniquePointer(const UniquePointer&) { } 
    virtual ~UniquePointer() { } 
}; 

Answer 4

pienso que su SafeDispose probablemente debería parecerse más a:

friend void SafeDispose(UniquePointer** p) ... 

Para invocarlo usando

SafeDispose(&(UniquePointer*)b); 

entonces debería funcionar de esta manera.

Pero su próximo estado de

b->Dispose(); 

romperá causa b debe ahora ser NULL, porque se ha dispuesto y establecido en NULL por el método de SafeDispose.

Answer 5

Para responder el título de su pregunta, no puede enlazar una referencia no const a base a una instancia de clase derivada porque podría establecer esa referencia a un puntero a una instancia base que no sea derivada. Considere esta función:

void Renew(UniquePointer *& p) { 
    delete p; 
    p = new UniquePointer(); 
} 

si pudiera pasar un puntero a Building que sería capaz de establecer de forma incorrecta para que apunte a una instancia UniquePointer.

Como ya se ha sugerido, la solución es cambiar su referencia a un puntero simple. No solo esto resuelve su problema, sino que también es una mejor implementación de SafeDispose(); como lo escribiste esta función dio la falsa idea de que siempre establecerías en 0 todas tus instancias UniquePointer. Pero ¿qué pasaría si alguien escribió (suponiendo UniquePointer constructor era pública para simplificar):

UniquePointer *p1 = new UniquePointer(); 
UniquePointer *p2 = p1; 
SafeDispose(p1); 

Ellos esperarían que la totalidad de sus UniquePointer s para ser debidamente atendidos, cuando p2 es realmente válido.