Discussion :

[Aladore]

Bonsoir !
Au cours de mon projet, je suis souvent amené à utiliser le reinterpret_cast car à un certains moment je sais que j'utilise un type plus bas dans mon héritage qui possède certaines fonctions dont j'ai besoin. Cependant, ça m'a pas l'air jolie comme façon de faire, est-ce vous pensez que c'est quelque chose à éviter ?

Edit:
Euh, j'ai un énorme doute là. Admettons j'ai:

Code :

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

1
2
3
4
5
6
 
class A{};
class B : public A {};
class C : public A {};
class D : public B {};
class E : public C {};

Et que au cours de l'exécution, je sache si je manipule un E ou D, mais que j'ai un pointeur sur un A (où A m'est fourni par une lib externe). Le mieux, c'est de faire static_cast<E*>(ptrA) ou reinterpret_cast<E*>(ptrA) ?

[TheDrev]

D'après la faq http://cpp.developpez.com/faq/cpp/?page=conversions
c'est plutot un dynamic_cast dont tu as besoin. A utiliser avec précaution, le RTTI n' pas très bonne presse. Mais dans le cas de l'utilisation d'une lib externe il peut se justifier (sans vouloir relancer ce débat une énième fois).

[Aladore]

Mais euh, pourtant ça marche si je fais un static_cast ... C'est étrange ça.

[3DArchi]

Mais euh, pourtant ça marche si je fais un static_cast ... C'est étrange ça.

static_cast réalise le transtypage à la compilation sans tenir compte du type dynamique effectif de ton pointeur. S'il est compatible alors pas de problème, sinon le comportement est indéterminé.
dynamic_cast s'appuie sur le type dynamique pour vérifier le transtypage. Si celui-ci est incompatible, alors le résultat est un pointeur nul (une exception si utilisé avec des références) :

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
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
struct A{
    int a;
    A():a(0){}
    virtual ~A(){} // dynamic_cast nécessite que la classe soit polymorphe
};
struct B : public A{
    int b;
    B():b(1){}
};
struct C : public A{
    int c;
    C():c(2){}
};
 
int main()
{
    A a;
    B b;
    C c;
 
    A*pa;
    B*pb;
    C*pc;
 
 
    pa = &a;
    pb = static_cast<B*>(pa);// compil OK, exécution indéterminée (probablement pb!=NULL et membre==n'importe quoi)
    pc = dynamic_cast<C*>(pa);// à l'exécution pc == NULL;
 
    pa = &b;
    pb = static_cast<B*>(pa);// compil OK, exécution OK
    pc = dynamic_cast<C*>(pa);// à l'exécution pc == NULL;
 
    pa = &c;
    pb = static_cast<B*>(pa);// compil OK, exécution indéterminée (probablement pb!=NULL et membre==n'importe quoi)
    pc = dynamic_cast<C*>(pa);// pc!=NULL
 
    return 0;
}

Cf Les fonctions virtuelles en C++, Conversions entre type de base et type dérivé


Quant à 'est-ce bien ou mal de faire un transtypage', cf F.A.Q. :
Pourquoi l'utilisation du downcasting est-il souvent une pratique à éviter ?

[screetch]

dans tous les cas de figure, ce reinterpret_cast est a proscrire, il est faux.

[Goten]

static_cast réalise le transtypage à la compilation

Pas forcément... Il ne tient compte que tu type statique oui, mais le cast n'est pas dans tout les cas fait à la compilation, il peut être fait au runtime.