Disons que nous avons une classe de base abstraite IBase
avec des méthodes virtuelles pures (une interface).
Ensuite, nous dérivons CFoo
, CFoo2
de la classe de base.
Et nous avons une fonction qui sait comment travailler avec IBase.
Foo(IBase *input);
Le scénario habituel dans ces cas est le suivant:
IBase *ptr = static_cast<IBase*>(new CFoo("abc"));
Foo(ptr);
delete ptr;
Mais il vaut mieux éviter la gestion des pointeurs, donc existe-t-il un moyen d'utiliser des références dans un tel scénario?
CFoo inst("abc");
Foo(inst);
où Foo
est:
Foo(IBase &input);
Oui. Vous n'avez pas à transposer vos objets. Toutes les références/pointeurs vers des types dérivés sont convertis implicitement en références/pointeurs d'objets de base si nécessaire.
Donc:
IBase* ptr = new CFoo("abc"); // good
CFoo* ptr2 = static_cast<CFoo*>(ptr); // good
CFoo* ptr3 = ptr; // compile error
CFoo instance("abc");
IBase& ref = instance; // good
CFoo& ref2 = static_cast<CFoo&>(ref); // good
CFoo& ref3 = ref; // compile error
Lorsque vous devez abattre, vous pouvez envisager d'utiliser dynamic_cast
, si vos types sont polymorphes.
Vous pouvez caster un objet comme vous pouvez le faire avec un pointeur. Je me souviens que c'était courant lors de la conversion de char
en unsigned char
et divers autres signes changeant les jets dans les jours d'autrefois.