Le implementazioni di ereditarietà virtuale C++ di diversi compilatori non sono compatibili?

Question

Ho gerarchia di interfacce pubbliche in questo modo:

struct ISwitchable { 
    /* Obtain pointer to another implemented interface of the same instance. */ 
    virtual int switch(unsigned int interfaceId, void** pInstance) = 0; 
}; 
struct IFoo : public ISwitchable { /* Methods */ }; 
struct IBar : public ISwitchable { /* Methods */ }; 
struct IFooBar : public IFoo, public IBar { /* Methods */ }; 

classe che implementa IFooBar è inserito nel dll con la funzione di fabbrica. Il codice client carica dll, usa la funzione factory per creare un'istanza di classe e usarla secondo le interfacce (vengono fornite come file di intestazione).

schema funziona bene con dll fatta da MSVC e il codice cliente da parte di Borland C++ Builder 6.

introduco eredità virtuale in gerarchia:

struct IFoo : public virtual ISwitchable { /* Methods */ }; 
struct IBar : public virtual ISwitchable { /* Methods */ }; 

E quando nella stessa situazione (DLL MSVC , client by Builder) codice client richiede istanza di classe che ottiene con vtable disordinato.

Esiste una soluzione ad eccezione del rollback sull'eredità ordinaria?

Answer 1

Probabilmente non risponderà alla tua domanda ... Ma si consiglia vivamente di NON usare l'ereditarietà multipla come si fa (chiamato "diamante temuto").

Answer 2

Non pensavo che si potesse contare su classi costruite compatibili con i compilatori. Borland afferma di poter caricare e interoperare con le classi create da MSVC. Se è così, sembra che abbiano un bug. Per quanto ne so, nulla sulla struttura esatta del VTable è nelle specifiche del C++, quindi non è previsto che funzioni sui compilatori.

Answer 3

A differenza di C, non esiste un cross-compilatore ABI per C++ - i compilatori sono liberi di implementare l'ereditarietà virtuale (e persino l'ereditarietà ordinaria) in qualsiasi modo.

Il risultato è: non è garantito il funzionamento delle funzioni C++ tra i compilatori. So che è brutto, ma se vuoi che la tua DLL interagisca felicemente con più compilatori, probabilmente hai fornito meglio una serie di semplici funzioni extern "C" e tabelle di punti di funzione create manualmente.

Nota: I compilatori che supportano la creazione di oggetti COM (o che hanno un'opzione per farlo) sono più limitati nei loro layout di oggetti. (So ​​che le versioni recenti di MSVC++ producono oggetti compatibili con COM, almeno nella maggior parte dei casi - non sono sicuro se l'ereditarietà virtuale è coperta però.)

Answer 4

Sono sospettoso dell'argomento void**. L'uso di puntatori void perde le informazioni sul tipo.

Se si lavora con ereditarietà multipla, digitare le informazioni può essere importante. Considerare:

class Foo { ... }; 
class Bar { ... }; 

class Both: public Foo, public Bar { ... }; 

Supponiamo che internamente il layout di un'Istanza sia un'istanza di Foo seguita da un'istanza di Barra. Posso passare entrambi * a un metodo che prevede un Foo * senza problemi. Posso anche passare un * ad un metodo che prevede una barra *, a condizione che aggiusti il ​​puntatore in modo che punti alla barra incorporata. Posso farlo in modo affidabile perché so che sto lavorando con entrambi.

Ora:

Foo *foo = new Both(...); 
Bar *bar = new Both(...); 

void *p = foo; 
void *q = bar; 

Both *both = (which) ? (Both*)p : (Both*)q; 

Quindi: come faccio a sapere come regolare sia p o q quando assegno a "entrambi"? Non posso perché le informazioni sul tipo vengono perse passando attraverso il puntatore del vuoto.

Una variante di questo problema potrebbe essere correlata ai problemi che si verificano.