È possibile dynamic_cast da una classe base all'altra?

Question

Per esempio Ho codice come quello

class Base1 
{ 
    virtual void wonderFULL() = 0; 
}; 

class Base2 
{ 
    // all this weird members 
}; 

class Derived : public Base1, public Base2 
{ 
    // not so weird members 
}; 

int main() 
{ 
    Derived Wonder; 
    magicFunction(&Wonder); 
    return 0; 
} 

void magicFunction(Base2 *ptr) 
{ 
    if (Base1 *b1 = dynamic_cast<Base1 *>(ptr)) 
    b1->wonderFULL(); 
} 

Tuttavia Wonderfull non viene mai eseguito a causa di impossibilità di lanciare ptr a b1. È possibile eseguire una simile conversione?

Answer 1

Passando da quello che ho capito del modo in cui alcuni compilatori C++ organizzano la gerarchia di classi in memoria dovrebbe essere possibile eseguire il cast da una classe base all'altra, ma è necessario prima eseguire il cast sulla classe derivata.

Pertanto si avrebbe bisogno di fare qualcosa di simile:

Base1* b1 = dynamic_cast<Derived*>(ptr); 

Questo getta la data puntatore ptr alla classe derivata, e poi viene implicitamente espressi a suo altro puntatore alla classe base.

Tuttavia, un altro modo più semplice per farlo sarebbe semplicemente avere un metodo nella classe Base2 che restituisce un puntatore Base1 e la classe derivata può implementarlo senza alcun codice complicato. (La stessa funzione in Base2 può solo restituire NULL se non vuoi una pura classe virtuale).

Answer 2

Questo

#include <iostream> 

class Base1 { 
public: 
    virtual void wonderFULL() = 0; 
}; 

class Base2 { 
public: 
    virtual ~Base2() {}          // added so the code compiles 
}; 

class Derived : public Base1, public Base2 { 
    virtual void wonderFULL() {std::cout << "wonderful\n";} // added so the code compiles 
}; 

void magicFunction(Base2 *ptr) { 
    if (Base1 *b1 = dynamic_cast<Base1 *>(ptr)) 
     b1->wonderFULL(); 
} 

int main() { 
    Derived Wonder; 
    magicFunction(&Wonder); 
    return 0; 
} 

stampe wonderful per me. La mia conclusione è che non stai mostrando il codice necessario per la riproduzione del tuo problema.

Prendere (una copia di) il codice effettivo e rimuovendo il codice non necessario passo dopo passo distillandolo fino a quando non si ottiene un self-contained (non ha bisogno di altre intestazioni tranne dalla lib di std), esempio compilabile che riproduce il problema. Molto probabilmente troverai il problema mentre lo fai. Tuttavia, se non lo fai, hai il perfetto caso di riproduzione per tornare qui e chiedere informazioni.

Answer 3

Si può lanciare in alto nella gerarchia poi di nuovo giù:

void magicFunction(Base2& ptr) 
{ 
    try 
    { 
     Derived& d = dynamic_cast<Derived&>(ptr); 
     Base1& b = dynamic_cast<Base1&>(d); 
     b.wonderFULL(); 
    } 
    catch(const std::bad_cast&) 
    { /* Cast failed */ } 
} 

Answer 4

Hai alcuni errori di sintassi, ma il problema reale è dynamic_cast non funziona correttamente se le classi di base non hanno almeno una virtuale funzione.

Se fai sembrare:

class Base2 
{ 
public: 
    virtual ~Base2() {} 
    // all this weird members 
}; 

E poi fissare i tuoi altri errori: wonderFULL è privato, e mai definito. magicFunction viene dichiarato dopo l'uso.

Quindi tutto works.

Answer 5

Ho trovato il problema. Non si trattava di dynamic_casts. Stavo controllando oggetti errati che non sono stati ereditati dalla base astratta. Grazie.