FAQ C++Consultez toutes les FAQ

Contrairement au C, les cast C++ sont effectués au moyen d'opérateurs spécifiques (mots-clés réservés). Le choix de ces opérateurs dépend du type de cast, car le C++ différencie quatre types de conversion explicite. Tout d'abord, trois opérateurs sont dédiés aux conversions statiques (effectuées à la compilation) :

1. static_cast : entre types de même famille. Il s'agit la plupart du temps d'expliciter des conversions qui auraient pu être effectuées de manière implicite, mais souvent avec un avertissement du compilateur.
   
   

   Code c++ :

   Sélectionner tout

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   // conversion de int en char 
   int i = 100; 
   char c = static_cast<char>( i ); 
     
   // conversion de float en int 
   float f = 100.0f; 
   i = static_cast<int>( f ); 
     
   // conversion classes dérivée -> classe parent 
   class A {}; 
   class B : public A {}; 
     
   B *b = new B; 
   A *a = static_cast<A*>( b );

2. reinterpret_cast : entre types de familles différentes. Il s'agit simplement de dire au compilateur « je sais que je manipule une donnée de type X, mais on va faire comme si elle était de type Y ». De ce fait aucune donnée n'est physiquement modifiée, cet opérateur de conversion n'est qu'une indication pour le compilateur.
   
   

   Code c++ :

   Sélectionner tout

   1
   2
   3
   4
   5
   6
   7
   8
   9
   // Conversion de int en pointeur de char 
   int i; 
   char * ptr = reinterpret_cast<char*>( i ); 
     
   // Conversion de int en référence sur char 
   char & ref = reinterpret_cast<char&>( i ); 
     
   // Conversion pointeur de char -> pointeur de double 
   double * ptr2 = reinterpret_cast<double*>( ptr );

3. const_cast: entre un type donné constant et le même type avec / sans les qualificateurs const ou volatile. Cet opérateur est rarement utilisé, car :
   
   • La conversion non-const -> const est implicite.
   • La conversion const -> non-const relève en fait bien souvent d'une erreur de conception.
   • Le qualificateur volatile est rarement utilisé.
     
   
   
   

   Code c++ :

   Sélectionner tout

   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   class A {}; 
     
   // Conversion de const A * en A * 
   const A * cptr; 
   A * ptr = const_cast<A*>( cptr ); 
     
   // Conversion de const A & en A & 
   A a; 
   const A & cref = a; 
   A & ref = const_cast<A&>( cref );

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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
#include <iostream> 
#include <string> 
#include <typeinfo> 
  
class A 
{ 
public: 
    virtual std::string get_type() = 0; 
}; 
  
class B : public A 
{ 
public: 
    virtual std::string get_type() { return "B"; } 
}; 
  
class C : public A 
{ 
public: 
    virtual std::string get_type() { return "C"; }; 
}; 
  
A * create_B_or_C() 
{ 
    static int nb = 0; 
    // si nb est pair, on crée un B, sinon un C 
    ++nb; 
    if ( nb % 2 == 0 ) { return new B; } 
    return new C; 
} 
  
int main() 
{ 
    for ( int i = 0; i < 5; ++i ) 
    { 
        A *a = create_B_or_C(); 
        std::cout << "Test sur un " << a->get_type() << " : "; 
  
        B *b = dynamic_cast<B*>( a ); 
        if ( b == 0 ) 
        { 
            // échec du cast en B, il doit s'agir d'un C 
            // lève std::bad_cast s'il ne s'agit pas d'un C 
            try 
            { 
                C & c = dynamic_cast<C&>( *a ); 
                std::cout << "il s'agit d'un C.\n"; 
            } 
            catch ( const std::bad_cast & ) 
            { 
                std::cout << "Oups!\n"; 
            } 
        } 
        else 
        { 
            std::cout << "il s'agit d'un B.\n"; 
        } 
        delete a; 
    } 
}

On est souvent tenté d'utiliser l'opérateur de conversion dynamic_cast pour effectuer un downcasting (voir Comment effectuer une conversion de type explicite (cast) ?), mais il s'agit fréquemment d'une erreur. Pourquoi ? Car conceptuellement parlant, on a en réalité rarement besoin de connaître le type réel d'un objet que l'on manipule via sa classe de base. Si l'on se retrouve dans une telle situation, c'est probablement que :

• La fonction que l'on écrit ne travaille en fait pas sur la classe de base, mais seulement sur certaines classes dérivées bien identifiées.
• On n'a pas exploité un éventuel polymorphisme dynamique (utilisation des fonctions virtuelles, voir Que signifie le mot-clé virtual ?).
• On n'a pas exploité un éventuel polymorphisme statique (utilisation des templates et des surcharges).
• On a mal conçu notre hiérarchie.
  

Le cross-casting est une possibilité offerte par le C++ grâce à son support de l'héritage multiple. Dans l'exemple suivant :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// A   B 
//  \ / 
//   C 
  
class A 
{ 
public: 
    virtual ~A(); 
}; 
  
class B 
{ 
public: 
    virtual ~B(); 
}; 
  
class C : public A, public B 
{ 
};

1
2
A *a = new C; 
B *b = dynamic_cast<B*>( a );

1
2
3
A *a = new C; 
C *c = dynamic_cast<C*>( a ); // downcasting de A en C 
B *b = static_cast<B*>( c );  // cast de C en B