Application du pointeur au type de pointeur lors de la compilation

Question

J'ai un scénario de désérialisation pour une hiérarchie d'objets, dans lequel la plupart des objets contiennent des pointeurs vers d'autres objets, mais ne les possèdent pas.

Je suis en train de mettre en œuvre un processus en deux étapes dans lequel:

1. Les objets sont créés, Register(Object* pObject) ed à un ID, les données sont lues. Les membres de pointeur sont sérialisés en tant qu'ID uniques, donc en les relisant, je RegisterResolver(int id, Object** ppMember) s.
2. Les résolveurs sont traités: les ID sont recherchés et l'adresse correcte est écrite à l'adresse *ppMember (remarquez le déréférencement).

Le problème:

• Je veux faire valoir que seuls les pointeurs vers des objets ou issus d'une certaine classe Base être enregistré, mais Derived** ne peut pas être converti en Base**.
• Je veux au moins éviter toute ambiguïté lors de l'utilisation void* (non void**) que Derived**/Base** peut être à la fois converti, mais alors si vous Derived*/Base*.

Dans le scénario suivant:

struct A: public Serialized 
{ 
    int blah; 
}; 

struct B: public Serialized 
{ 
    float fBlah; 
    A* pTarget; 
}; 

B myB; 

Si l'interface est RegisterResolver(int id, void* ppObject), il n'y a aucune garantie que le code client ne passera pas myB.pTarget au lieu de &myB.pTarget.

Que puis-je faire pour améliorer la sécurité [de type] et la lisibilité de cette solution?

(Les plates-formes cibles sont x86 et ARM.)

Answer 1

Comme la question d'origine a également été lisibilité et j'inquiétant voulu minimiser les paramètres pouvant prêter à confusion sur l'interface, j'ai Iterated sur la réponse de Ben Voigt et a fini avec ceci:

template<typename T> 
void RegisterResolver(int id, T** ppObject) 
{ 
    // assert(ppObject != 0); 
    Base* pBase(*ppObject); // not used 

    // implementation 
} 

Answer 2

Un modèle devrait aider. Que diriez-vous

template<typename T> 
void RegisterResolver(int id, T** ppObject, Base* extra = (T*)0); 

Cela permet un argument de tout type Derived** pour lequel il y a une conversion implicite Derived*-Base*.