ereditarietà multipla: risultato inatteso dopo il cast da void * a 2a classe base

Question

Il mio programma deve utilizzare il void * per trasportare dati o oggetti in situazione di invocazione dinamica, in modo che possa fare riferimento a dati di tipi arbitrari, anche primitivi tipi. Tuttavia, ho scoperto di recente che il processo di down-casting di questi void * in caso di classi con più classi di base fallisce e addirittura causa l'arresto anomalo del mio programma dopo aver richiamato i metodi su questi puntatori downed cast anche se gli indirizzi di memoria sembrano essere corretti. L'arresto si verifica durante l'accesso a "vtable".

Così ho creato un piccolo banco di prova, l'ambiente è gcc 4.2 su Mac OS X:

class Shape { 
public: 
    virtual int w() = 0; 
    virtual int h() = 0; 
}; 

class Square : public Shape { 
public: 
    int l; 
    int w() {return l;} 
    int h() {return l;} 
}; 

class Decorated { 
public: 
    int padding; 
    int w() {return 2*padding;} 
    int h() {return 2*padding;} 
}; 

class DecoratedSquare : public Square, public Decorated { 
public: 
    int w() {return Square::w() + Decorated::w();} 
    int h() {return Square::h() + Decorated::h();} 
}; 


#include <iostream> 

template <class T> T shape_cast(void *vp) { 
// return dynamic_cast<T>(vp); // not possible, no pointer to class type 
// return static_cast<T>(vp); 
// return T(vp); 
// return (T)vp; 
    return reinterpret_cast<T>(vp); 
} 

int main(int argc, char *argv[]) { 
    DecoratedSquare *ds = new DecoratedSquare; 
    ds->l = 20; 
    ds->padding = 5; 
    void *dsvp = ds; 

    std::cout << "Decorated (direct)" << ds->w() << "," << ds->h() << std::endl; 

    std::cout << "Shape " << shape_cast<Shape*>(dsvp)->w() << "," << shape_cast<Shape*>(dsvp)->h() << std::endl; 
    std::cout << "Square " << shape_cast<Square*>(dsvp)->w() << "," << shape_cast<Square*>(dsvp)->h() << std::endl; 
    std::cout << "Decorated (per void*) " << shape_cast<Decorated*>(dsvp)->w() << "," << shape_cast<Decorated*>(dsvp)->h() << std::endl; 
    std::cout << "DecoratedSquare " << shape_cast<DecoratedSquare*>(dsvp)->w() << "," << shape_cast<DecoratedSquare*>(dsvp)->h() << std::endl; 
} 

produce il seguente output:

Decorated (direct)30,30 
Shape 30,30 
Square 30,30 
Decorated (per void*) 73952,73952 
DecoratedSquare 30,30 

Come si può vedere, la "Decorato (per vuoto *) "il risultato è completamente sbagliato. Dovrebbe anche essere 30,30 come nella prima riga.

Qualunque metodo di cast che utilizzo in shape_cast() otterrò sempre gli stessi risultati imprevisti per la parte Decorated. C'è qualcosa di completamente sbagliato in questi vuoti *.

Dalla mia comprensione di C++ questo dovrebbe essere effettivamente funzionante. C'è qualche possibilità di farlo funzionare con il vuoto *? Può essere un bug in gcc?

Grazie

Answer 1

Non è un bug del compilatore, è ciò che fa reinterpret_cast. L'oggetto DecoratedSquare sarà presentato in memoria di qualcosa di simile:

Square 
Decorated 
DecoratedSquare specific stuff 

Conversione di un puntatore a questo per void* darà l'indirizzo di inizio di questi dati, senza alcuna conoscenza di ciò che tipo è lì. reinterpret_cast<Decorated*> prenderà quell'indirizzo e interpreterà qualsiasi cosa ci sia come Decorated - ma il contenuto della memoria reale è lo Square. Questo è sbagliato, quindi ottieni un comportamento indefinito.

Si dovrebbe ottenere i risultati corretti se si reinterpret_cast al tipo dinamico corretto (ovvero DecoratedSquare), quindi convertire nella classe base.

Answer 2

Uno static_cast o un dynamic_cast in presenza di ereditarietà multipla può cambiare la rappresentazione del puntatore mediante compensazione in modo che designa l'indirizzo corretto. static_cast determina l'offset corretto considerando le informazioni di tipizzazione statiche. dynamic_cast lo fa controllando il tipo dinamico. Se vai a throw void *, stai perdendo tutte le informazioni di tipizzazione statiche e la possibilità di ottenere informazioni di digitazione dinamiche, quindi il reinterpret_cast che stai utilizzando presuppone che l'offset sia nullo, in mancanza di alcune volte.

Answer 3

Ripetere dieci volte: l'unica cosa che si può tranquillamente fare con un puntatore reinterpret_cast è reinterpret_cast riportandolo allo stesso tipo di puntatore da cui proviene. Lo stesso vale per le conversioni su void*: è necessario riconvertire il tipo originale.

Pertanto, se si trasmette un valore da DecoratedSquare* a void*, è necessario trasmetterlo nuovamente a DecoratedSquare*. Non Decorated*, non Square*, non Shape*. Alcuni di questi potrebbero funzionare sulla tua macchina, ma questa è una combinazione di buona fortuna e comportamento specifico dell'implementazione.Di solito funziona con l'ereditarietà singola, perché non vi è alcun motivo ovvio per implementare i puntatori di oggetti in un modo che lo bloccherebbe, ma ciò non è garantito e non può funzionare in generale per l'ereditarietà multipla.

Si dice che il proprio codice accede a "tipi arbitrari, compresi i tipi primitivi" tramite un vuoto *. Non c'è niente di sbagliato in questo - presumibilmente chiunque riceve i dati sa di trattarlo come un DecoratedSquare* e non come, diciamo, int*.

Se chi lo riceve solo sa trattarlo come una classe base, come ad esempio Decorated*, allora chi lo converte in void* dovrebbe static_cast alla classe base, poi a void*:

void *decorated_vp = static_cast<Decorated*>(ds); 

Ora, quando lanci decorated_vp di nuovo a Decorated*, otterrai il risultato di static_cast<Decorated*>(ds), che è quello che ti serve.