Discussion :

[Invité]

Salut, j'ai lu que dynamic_cast utilise le RTTI pour faire le cast d'un objet de base vers un objet dérivé.

Alors ce que je voudrais savoir c'est si il y a moyen de faire ceci :

Code cpp :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
dynamic_cast<object->getType()>(object);

Ou getType() me renvoie juste une variable de type type_info. (Donc contenant les informations sur le type de l'objet à l'exécution)

Le problème c'est que ça ne compile pas il me dit espected type specifier before object.

Alors je voudrais savoir si il n'y a pas un moyen de dire au compilateur de ne pas évaluer ça à la compilation mais de laisser le code compiler pour que ça fasse le cast à l'exécution ???

[jo_link_noir]

Non, pour la bonne raison que les casts se font sur des types et non sur des valeurs. Et il y a un constat très simple à faire : les types manipulés ne sont pas dynamique (le type réel si, mais on ne peut le connaître sans plus d'information que le type manipulé).
Quant il faut "dynamiser les types", tu peux aller de l'avant (appeler des fonctions avec des types différents en fonction de valeur) mais jamais reculer car le type de retour ne changera pas. En fait, seul les prototypes des fonctions et un graph d'appel suffisent pour suivre l'évolution d'un type.

Même chose pour les valeurs constexpr/template.

[Médinoc]

@Lolilolight: Non tu ne peux pas, car tu ne pourrais pas déclarer la variable dans laquelle tu mettrais le résultat (vu qu'elle n'aurait pas de type connu).

[koala01]

Salut,

Déjà, il faut savoir que, si tu te trouves face à une situation dans laquelle tu dois utiliser le dynamic_cast, c'est très vraisemblablement le symptôme d'un problème de conception dans le sens où "tu as été assez bête" pour en arriver à connaitre un objet selon son type de base plutôt que selon son type le plus dérivé.

A partir de là, il y a bien quelques circonstances toutes particulières dans lesquelles le dynamic_cast peut s'avérer intéressant voire indispensable, mais de manière générale, tu ne devrais jamais envisager de l'utiliser pour déterminer si ton objet qui passe pour être du type de base est un objet d'un type dérivé donné. Les mots clé pour t'en sortir sont virtualité des fonctions, pour être en mesure de faire varier le comportement d'un objet en fonction de son type réel et double dyspatch pour pouvoir demander à l'objet d'agir selon les capacités de son type le plus dérivé

[Invité]

Ok je vois je vais essayer de m'en sortir avec du double dispach alors..., bon, dans le cas des méthodes template qui ne peuvent pas être virtuelles là je n'ai pas le choix, je suis obligé d'utiliser une fonction qui renvoie un std::string sur le type de l'objet et de faire un cast si je veux effectuer un action sur l'objet dérivé.

Par exemple, comme ici :

Code cpp :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
 template <typename C>
    bool intersects(BoundingVolume<C>& other) {
        //if(static_cast<C&>(other)) {
            if (children.size() == 0 && other.children.size() == 0) {
                return intersects(dynamic_cast<C&>(other));
            }  else if (children.size() == 0 && other.children.size() != 0) {
                  for (unsigned int i = 0; i < other.children.size(); i++) {
                      if (other.children[i]->getType() == "BoundingBox")
                          if (intersects(dynamic_cast<BoundingVolume<BoundingBox>&>(*other.children[i])))
                                return true;
                  }
            } else {
                for (unsigned int i = 0; i < children.size(); i++) {
                    if (other.children.size() == 0) {
                        if (children[i]->getType() == "BoundingBox")
                            if (static_cast<BoundingVolume<BoundingBox>*>(children[i])->intersects(static_cast<BoundingVolume<C>&>(other)))
                                return true;
 
                    } else {
                        for (unsigned j = 0; j < other.children.size(); j++) {
                            if (children[i]->getType() == "BoundingBox" && other.children[i]->getType() == "BoundingBox")
                                if (static_cast<BoundingVolume<BoundingBox>*>(children[i])->intersects(static_cast<BoundingVolume<BoundingBox>&>(*other.children[j])))
                                    return true;
                        }
                    }
                }
            }
        //}
        return false;
    }

Vu que mes différents types de volumes doivent être stocké dans un contenaire je suis obligé d'utiliser le pattern CRTP et type erasure, donc, je suis également obligé de faire un cast.

[koala01]

Si tu pars sur un tel principe, tu t’ampute littéralement de trois doigts!!!!

Non, ce que tu peux faire, étant donné que tu pars visiblement sur du CRTP, c'est faire en sorte d'avoir un alias de type (DataType, par exemple) qui corresponde au paramètre template de ta classe, et une fonction qui renvoie une référence (constante au besion) sur l'objet en question.

Cela donnerait un truc du genre de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
template <typename T>
class Interface{
    public:        using DataType = T;
        DataType /* const */ & data() /* const*/{return t_;}
    protected:
        Interface(T & t) : t_(t){}
        ~Interface(){}
    private:
        T & t_;
};
 
class MaClasse : public Interface<MaClasse>{
 
    public:
        MaClasse():Interface<MaClasse>(*this){}
        void foo():
        /*... */
}
template <typename T> 
void bar(Interface<T> const &  iface){
    iface.data().foo();
}

Avec la spécialisation partielle, rien ne t'empêche de prévoir d'autres comportements que foo en cas de besoin