C++ ne peut pas convertir à partir d'Une base de dérivés de type B, par l'entremise de base virtuelle d'Un

J'ai trois classes:

class A {};

class B : virtual public A {};
class C : virtual public A {};

class D: public B, public C {};

De tenter une statique de la fonte de A* B* j'obtiens l'erreur ci-dessous:

cannot convert from base A to derived type B via virtual base A

InformationsquelleAutor Panayiotis Karabassis | 2010-09-19

c++casting downcast static-cast virtual-inheritance

90

Afin de comprendre le système des castes, vous avez besoin de plonger dans le modèle objet.

La représentation classique d'une hiérarchie simple modèle est de confinement: si B dérive de A puis le B objet, en effet, contenir une A sous-objet côtés de ses propres attributs.

Avec ce modèle de passer est une simple manipulation du pointeur par un décalage connue au moment de la compilation, qui dépend de la disposition de la mémoire de B.

C'est ce que static_cast n': une statique de la fonte est surnommé statique car le calcul de ce qui est nécessaire pour la fonte est faite à la compilation, soit de l'arithmétique des pointeurs ou des conversions (*).

Toutefois, lorsque virtual héritage des coups de pied dans, les choses ont tendance à devenir un peu plus difficile. Le principal problème est que, avec virtual l'héritage de toutes les sous-classes partagent la même instance de la sous-objet. Pour ce faire, B va avoir un pointeur vers une A, au lieu d'une A propre, et le A objet de classe de base sera instancié à l'extérieur de B.

Par conséquent, il est impossible au moment de la compilation pour être en mesure de déduire le nécessaire de l'arithmétique des pointeurs: il dépend de l'exécution type de l'objet.

Chaque fois qu'il y a un temps d'exécution type de dépendance, vous avez besoin de RTTI (RunTime Type d'Information), et l'utilisation de RTTI pour la contention est le travail de dynamic_cast.

En résumé:
- au moment de la compilation abattu: static_cast
- au moment de l'exécution abattu: dynamic_cast
Les deux autres sont aussi au moment de la compilation de moulages, mais ils sont si spécifiques qu'il est facile de se rappeler ce qu'ils sont... et elles sont malodorantes, afin de mieux ne pas les utiliser du tout de toute façon.

(*) Comme le fait remarquer @curiousguy dans les commentaires, cela ne tient que pour passer. Un static_cast permet upcasting quel que soit virtuel ou de l'héritage simple, mais ensuite, le casting est également inutile.
- Belle réponse qui m'a fait comprendre comment l'héritage virtuel fonctionne réellement ! +1
- J'aime votre réponse, mais l'OP était apparemment en demandant au sujet d'une erreur pour PASSER plutôt que de upcasting.
- Merci pour l'erreur, je l'ai changé par "casting" pour "passer" et tout est bien maintenant.
- Faux. static_cast peut être utilisé pour convertir un dérivé ptr pour une base virtuelle ptr.
- En effet... même si vous n'avez même pas besoin d'un plâtre, donc je n'ai pas pensé à le prendre en compte. Ce qui pose la question de savoir pourquoi passer n'est pas disponible aussi.
- La conversion d'une classe de base est possible pour les non-polymorphe classes. dynamic_cast est possible uniquement pour les classes polymorphes: dynamic_cast signifie "utilise le vptr" (dans la plupart des cas). D'une conversion à une classe de base virtuelle utilise le vptr ou un pointeur interne (ou un fixe de décalage lors de la finale complète type est connu).
- Je ne suis pas d'accord. static_cast fait de la fonte au moment de l'exécution. Sortie (sans expression cast) est également effectuée au moment de l'exécution. Même s'il est vrai, que le code compilé est plus courte que pour dynamic_cast. Pour les pointeurs static_cast compile un if != nullptr, puis ajoute un offset connu au moment de la compilation. Toutefois, si l'héritage virtuel est inclus, static_cast et sortie compile également une if != nullptr, puis ajoute un offset connu au moment de l'exécution. Exemple. static_cast pouvez également appeler ctors., ce qui est aussi tout moment de l'exécution.
- Vous avez fait de nombreuses pts ici. 1) "pouvez également appeler ctors." en Effet static_cast peut faire beaucoup de chose. Je pensais que nous discutions ptr jette ici, non pas implicite conv en général, ou comment construire un obj. 2) Pouvons-nous accepter que le contexte est: faire de la même conversion de type X de type Y soit impl., w/ quelques casting oper ou d'une autre. 3) Pouvez-vous décrire X et Y tels que ces choix sont valables et donner diff code compilé?
- L' (*) phrase se termine par "ou à la conversion". J'ai donc pensé qu'il veut être général. J'ai édité la réponse. Il semble plus clair maintenant. Espère qu'il vous plaira. La première partie est sur le point de confinement: l'offset est connu à la compilation, si le haut ou abattu. Deuxième partie: à propos de l'héritage virtuel (abattu donne le message d'erreur, sortie possible, mais le décalage est connu au moment de l'exécution). 2) concentrons-nous sur jette entre les classes de type pointeurs. Sinon les termes de la compilation et de l'exécution obtenir facilement être mal interprétés. 3) je ne comprends pas ce que vous demandez. Ce choix?
- 1) Vous avez voulu être général, mais semble impliquer qu'un static_cast serait toujours appliquer un fixe décalage constant. 3) Le choix de deux de conversion de X et de Y, U->V entre un "nouveau style" cast *_cast, de style ancien en fonte, la conversion implicite pour les deux types U,V., auquel cas X et Y) à la fois valables b) différentes au mode de génération de code de niveau?
- Toujours pas sûr de ce que vous demandez. Ceci probablement n'est pas nouveau pour vous. Donc je ne sais pas. Peut-être il n'y a pas d'exemple. Poser une question sur StackOverflow.
InformationsquelleAutor Matthieu M.
12

Autant que je sache, vous devez utiliser dynamic_cast parce que l'héritage est virtual et vous êtes à la de passer.

InformationsquelleAutor Jon Purdy
6

Vous ne pouvez pas utiliser static_cast dans cette situation, car le compilateur ne sait pas le décalage de B par rapport à Une au moment de la compilation. Le décalage doit être calculé au moment de l'exécution basé sur le type exact de la plupart des dérivés de l'objet. Par conséquent, vous devez utiliser dynamic_cast.
- Lors de la conversion d'un dérivé d'une base virtuelle, vous pouvez utiliser static_cast.
- oui, mais la question est à propos de la conversion de la base de dérivés.
- Il n'est pas clair pourquoi votre argument ne s'applique pas aux dérivées à la base aussi.
- eh bien, si vous vous demandez pourquoi, je pense que c'est une bonne question et je ne suis pas sûr de connaître la réponse. Je suppose que c'est parce que les dérivés à base de plâtre est une question d'une simple indirection via la vtable, Pour la base de dérivé de fonte, d'autre part, vous devez effectuer la même (non constante de temps) algorithme de dynamic_cast pour les non-héritage virtuel. Ainsi, il y aurait par ailleurs pas être une différence entre statique et dynamique des moulages pour l'héritage virtuel. Ou mettre une autre manière, il n'y a aucune analogie pour les non-virtuel static_cast dans le virtuel-l'héritage de cas.
InformationsquelleAutor ybungalobill
4

Oui, vous devez utiliser un dynamic_cast, mais vous aurez à faire la classe de base polymorphe, par exemple en ajoutant une virtuel dtor.
- ou l'ajout d'au moins une méthode virtuelle.
InformationsquelleAutor Nico
4

Selon la norme docs,

Section 5.2.9 - 9, pour Statique de la Fonte,

Une rvalue de type “pointeur vers cv1 B, où B est un type de classe, peuvent être convertis en une rvalue de type “pointeur vers cv2
D, où D est une classe dérivée (clause 10) de B, si une conversion standard de “pointeur vers D” à “pointeur vers B”
existe (4.10), cv2 est le même cv-qualification, ou plus cv-qualification que, cv1, et B est ni une classe de base virtuelle
de D, ni une classe de base d'une classe de base virtuelle de D.

Par conséquent, il n'est pas possible et vous devez utiliser dynamic_cast...

InformationsquelleAutor liaK
1

$5.2.9/2- "Une expression e peut être
explicitement converti en type T à l'aide de
un static_cast de la forme
static_cast(e) si la déclaration
“T t(e);” est bien-formé, pour certains
inventé temporaire de la variable t (8.5)."

Dans votre code, vous tentez static_cast avec 'T = B*' et 'e = A*'

Maintenant 'B* t(A*)" n'est pas bien formé en C++ (mais 'A* t B*)' est parce que 'a' est Un virtuel sans ambiguïté et accessible à base de "B". Par conséquent, le code provoque une erreur.
- Fausse citation.
InformationsquelleAutor Chubsdad
1

Je ne sais pas si c'est "safe" mais.

En supposant

B dérivée à partir d'Une (et Une virtuelle pure)

Depuis que je SAIS qu'un pointeur vers B reste toujours un pointeur vers B.
```
    class A
    {
            virtual void doSomething(const void* p) const =0;
    };

    class B
    {
    public:
            int value;
            virtual void doSomething(const void*p)const
            {
            const B * other = reinterpret_cast<const B*>(p);
            cout<<"hello!"<< other->value <<endl;
            }
    };

    int main()
    {
            B  foo(1),bar(2);
            A * p = &foo, q=&bar;
            p->doSomething(q);
            return 0;
    }
```
ce programme s'exécute correctement et de retour d'impression "bonjour!" et la valeur de l'autre objet (dans ce cas "2").

par la voie, ce que je fais, c'est très dangereux (personnellement, je donne un ID différent pour chaque classe et j'affirme après réinterpréter le casting que le courant ID est égale à une autre pièce d'identité pour être sûr que nous faisons quelque chose avec 2 classes) et comme vous le voyez je me suis restreint à "const" méthodes. Ainsi, cela permettra de travailler avec des "non-const" méthodes, mais si vous faites quelque chose de mal à attraper le bug sera presque unpossible. Et même avec affirmation il y a 1 chance sur 4 milliards de réussir affirmation, même quand il est censé à l'échec
(assert(ID== autre->ID);)

Par la voie.. Un bon OO design ne doit pas exiger ce genre de choses, mais dans mon cas, j'ai essayé de refactor/re-conception du code, sans être en mesure de déposer l'utilisation de réinterpréter la coulée. de manière générale, vous POUVEZ éviter ce genre de choses.
- Êtes-vous sûr que c'est nécessaire?
- qui est spécifique à votre problème. un nouveau design devrait éviter ce dans la plupart des cas (éviter mon exemple, si vous le pouvez). oh j'ai oublier un "const".
- Je veux dire, êtes-vous sûr que vous en avez besoin? Que faire si je donne doSomething un int pointeur? Que serait un échec de façon désastreuse. Pourquoi ne pas utiliser une dynamique de fonte, et vérifiez le résultat? Je ne sais pas quoi exactement à vos exigences, mais je crois que, si vous apportez dans le polymorphisme statique du système (par exemple, les PFI modèle) vous pouvez venir avec quelque chose de plus sûr.
- polymorphisme statique n'est pas convenable dans beaucoup de cas, de toute façon dans mon code je fais que dans un type-sûre, de sorte que les utilisateurs n'ont aucune chance d'passa "int*" autour de. A l'origine, j'avais un "ID", mais j'ai trouvé plus tard meilleur système.. encore fois plus rapide que la dynamique de fonte.
- si vous êtes toujours intéressé comment ce code peut être utile, vous pouvez prendre un coup d'oeil à mon dernier projet. void* trucs sont utilisés dans plus d'un endroit.: code.google.com/p/infectorpp
InformationsquelleAutor GameDeveloper

Vous devez vous connecter pour publier un commentaire.