comment utiliser reinterpret_cast pour lancer un pointeur de classe dérivée en C++

Question

Voici mon exemple de test:

struct base { 
    virtual ~base(){} 
    int x; 
}; 

struct derived: public virtual base { 
    base * clone() { 
     return new derived; 
    } 
    derived(): s("a") {} 
    std::string s; 
}; 

int main() { 
    derived d; 
    base * b = d.clone(); 
    derived * t = reinterpret_cast<derived*>(b); 
    std::cout << t->s << std::endl; 
    return 0; 
} 

Il tombe en panne sur la ligne où imprimer s. Puisque "b" est un pointeur vers la classe dérivée, reinterpret_cast devrait simplement fonctionner. Je me demande pourquoi il se bloque. En même temps, si je remplace reinterpret_cast par dynamic_cast, alors cela fonctionne.

Answer 1

Même si b est ici dynamiquement de type derived, vous devez utiliser dynamic_cast. C'est ce que dynamic_cast est pour convertir dynamiquement un pointeur d'une classe de base en une classe dérivée au moment de l'exécution.

reinterpret_cast prend le pointeur brut et le considère comme étant du type dérivé. Toutefois, en raison de l'héritage virtual, un léger ajustement doit être effectué sur le pointeur pour pointer vers la table d'acheminement de méthode correcte, et c'est précisément ce que fera dynamic_cast.

Answer 2

Ne pas reinterpret_cast, il va causer des problèmes avec l'héritage multiple ou virtuel, comme dans votre cas. Wont un simplement static_cast faire le travail ici? Pour savoir pourquoi, recherchez des implémentations d'héritage virtuel. Un point commun est de stocker un pointeur sur la classe de base dans l'objet, de sorte que la base virtuelle ne partage pas la même adresse que ses classes dérivées. Il existe un cas similaire lorsque l'héritage multiple est utilisé.

En résumé, reinterpret_cast ne peut pas faire beaucoup plus que de lancer des pointeurs sur ints et back (s'il y a assez de taille dans l'int pour contenir un pointeur).

Answer 3

Comme les autres réponses ici proposées, vous ne pouvez pas utiliser reinterpret_cast de cette façon parce que la valeur du pointeur-base diffère réellement de la valeur du pointeur-derived. Le pointeur valide est déduit à l'exécution, c'est pourquoi vous devez utiliser dynamic_cast. Comme vous ne savez pas au moment de la conception par quel type intermédiaire la classe la plus dérivée (celle que vous voulez utiliser) a été dérivée du type pour lequel vous avez un pointeur.

La vraie question ici devrait être: Je sais au moment du design, comment calculer le pointeur derived à partir du pointeur base. Comment peut-on éviter la pénalité d'exécution (de dynamic_cast)?

Franchement, je ne vois pas une très bonne option, mais une option possible est de stocker le pointeur sur le type le plus dérivé d'un pointeur constant à l'intérieur de la classe racine, comme ceci:

struct base { 
    void* const self; 
    virtual ~base() {} 
    protected: 
    base(void* self) : self(self) {} 
}; 
struct derived : public virtual base { 
    derived() : base(this) {} 
} 

Ceci est moche et dangereux, car il sacrifie la sécurité de type pour la performance (si vous êtes vraiment chanceux, vous obtenez une légère performance d'exécution à partir de lui). Mais vous serez en mesure de reinterpret_cast votre pointeur base (le membre self de type void*) dans un pointeur derived.