FAQ C++Consultez toutes les FAQ

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
// ces fonctions renvoient false en cas d'erreur 
bool F1(); 
bool F2(); 
bool F3(); 
bool F4(); 
  
bool Test1() 
{ 
    // appeler F1 et F2 
    if ( !F1() ) 
    { 
        return false; 
    } 
    if ( !F2() ) 
    { 
        return false; 
    } 
    return true; 
} 
  
bool Test2() 
{ 
    // appeler Test1 et F3 
    if ( !Test1() ) 
    { 
        return false; 
    } 
    if ( !F3() ) 
    { 
        return false; 
    } 
    return true; 
} 
  
bool Test3() 
{ 
    // appeler Test2 et F4 
    if ( !Test2() ) 
    { 
        return false; 
    } 
    if ( !F4() ) 
    { 
        return false; 
    } 
    return true; 
} 
  
int main() 
{ 
    if ( !Test3() ) 
    { 
        std::cerr << "Une erreur est survenue, mais je ne sais pas où !"; 
    } 
}

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
// ces fonctions lèvent des exceptions en cas d'erreur 
void F1(); 
void F2(); 
void F3(); 
void F4(); 
  
void Test1() 
{ 
    F1(); 
    F2(); 
} 
  
void Test2() 
{ 
    Test1(); 
    F3(); 
} 
  
void Test3() 
{ 
    Test2(); 
    F4(); 
} 
  
int main() 
{ 
    try 
    { 
        Test3(); 
    } 
    catch ( const std::bad_alloc & ) 
    { 
         std::cerr << "Erreur : mémoire insuffisante.\n"; 
    } 
    catch ( const std::out_of_range & ) 
    { 
         std::cerr << "Erreur : débordement de mémoire.\n"; 
    } 
}

1
2
// lève une exception de type e 
throw e;

1
2
3
4
5
6
7
8
9
try 
{ 
    // instructions pouvant déclencher des exceptions 
    // dérivant de std::exception 
} 
catch ( const std::exception & e ) 
{ 
    std::cerr << e.what(); 
}

1
2
3
4
5
6
7
8
9
try 
{ 
    // déclencher une exception par pointeur 
    throw new int( 10 ); 
} 
catch ( const int * e ) 
{ 
    std::cerr << "Erreur numéro " << *e; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <iostream> 
#include <stdexcept> 
  
int main() 
{ 
    try 
    { 
        // std::logic_error est une classe standard 
        // qui dérive de std::exception 
        throw std::logic_error( "Exemple d'exception" ); 
    } 
    catch ( const std::exception & e ) 
    { 
        // affiche "Exemple d'exception" 
        std::cerr << e.what(); 
    } 
}

1
2
3
4
5
6
7
8
try 
{ 
    throw "Message d'erreur"; 
} 
catch ( const char * Msg ) 
{ 
    std::cerr << Msg; 
}

1
2
3
4
5
6
7
8
try 
{ 
    throw std::string( "Message d'erreur" ); 
} 
catch ( const std::string & Msg ) 
{ 
    std::cerr << Msg; 
}

1
2
3
4
5
6
7
8
9
10
int * ptr; 
try 
{ 
    // tenter d'allouer 100 entiers 
    ptr = new int [ 100 ]; 
} 
catch ( const std::bad_alloc & ) 
{ 
    // échec de l'allocation 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
try 
{ 
    // créer un tableau de taille 10 
    std::vector<int> tableau( 10 ); 
    // accéder au 11° élément 
    tableau.at( 10 ); 
} 
catch ( const std::exception & Exp ) 
{ 
    std::cerr << "Erreur : " << Exp.what() << ".\n"; 
} 
catch ( const std::bad_alloc & ) 
{ 
    std::cerr << "Erreur : mémoire insuffisante.\n"; 
} 
catch ( const std::out_of_range & ) 
{ 
    std::cerr << "Erreur : débordement de mémoire.\n"; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
try 
{ 
    // créer un tableau de taille 10 
    std::vector<int> tableau( 10 ); 
    // accéder au 11° élément 
    tableau.at( 10 ); 
} 
catch ( const std::bad_alloc & ) 
{ 
    std::cerr << "Erreur : mémoire insuffisante.\n"; 
} 
catch ( const std::out_of_range & ) 
{ 
    std::cerr << "Erreur : débordement de mémoire.\n"; 
} 
catch ( const std::exception & Exp ) 
{ 
    std::cerr << "Erreur : " << Exp.xhat() << ".\n"; 
} 
catch ( ... ) // traite toutes les autres exceptions 
{ 
    std::cerr << "Erreur inconnue.\n"; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <iostream> 
#include <stdexcept> 
  
int main() 
{ 
    using namespace std; 
  
    try 
    { 
        // std::logic_error hérite de std::exception 
        throw logic_error( "exception de test" ); 
    } 
    catch ( exception e ) // traitement par valeur 
    { 
        cerr << e.what(); 
    } 
}

catch ( const exception & e ) // traitement par référence

1
2
3
4
5
try { 
    // ... 
} catch(...) { 
    // ... 
}

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
#include <iostream> 
#include <stdexcept> 
  
void Test() 
{ 
    try 
    { 
        throw std::logic_error( "Exception de test" ); 
    } 
    catch ( const std::logic_error & e ) 
    { 
        std::cerr << "L'exception '" << e.what() 
                  << "' a été levée et va être relancée.\n"; 
        throw; // relancer l'exception courante 
    } 
} 
  
int main() 
{ 
    try 
    { 
        Test(); 
    } 
    catch ( const std::logic_error & e ) 
    { 
        std::cerr << "Erreur : " << e.what() << ".\n"; 
    } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream> 
#include <exception> 
  
// ancien gestionnaire 
void (*old_handler)(); 
  
// gestionnaire personnalisé 
void my_handler() 
{ 
    std::cerr << "Exception inattendue.\n"; 
    // appel du gestionnaire par défaut 
    (old_handler)(); 
} 
  
int main() 
{ 
    // installer notre gestionnaire personnalisé 
    old_handler = set_terminate( my_handler ); 
    // lever une exception que l'on ne traite pas 
    throw "test"; 
}

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
#include <iostream> 
#include <sstream> 
#include <exception> 
  
class my_exception : public std::exception 
{ 
public: 
    my_exception( const char * Msg, int Line ) 
    { 
        std::ostringstream oss; 
        oss << "Erreur ligne " << Line << " : " 
            << Msg; 
        this->msg = oss.str(); 
    } 
  
    virtual ~my_exception() throw() 
    { 
  
    } 
  
    virtual const char * what() const throw() 
    { 
        return this->msg.c_str(); 
    } 
  
private: 
    std::string msg; 
}; 
  
int main() 
{ 
    try 
    { 
        throw my_exception( "exception test", __LINE__ ); 
    } 
    catch ( const std::exception & e ) 
    { 
        std::cerr << e.what() << "\n"; 
    } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Test 
{ 
public: 
    // exception bad_alloc en cas de mémoire insuffisante 
    Test( int A, int B ) : 
        tableau1( 0 ), 
        tableau2( 0 ) 
    { 
        // ici tableau1 et tableau2 valent NULL, donc en cas d'échec d'allocation 
        // on peut appeler delete [] sans problème dans le destructeur 
        this->tableau1 = new int[ A ]; 
        this->tableau2 = new int[ B ]; 
    } 
    ~Test() 
    { 
        delete [] this->tableau2; 
        delete [] this->tableau1; 
    } 
  
private: 
    int * tableau1; 
    int * tableau2; 
};

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
class Test 
{ 
public: 
    // exception bad_alloc en cas de mémoire insuffisante 
    Test( int A, int B ) : 
        tableau1( 0 ) 
    { 
        // ici tableau1 vaut NULL, donc en cas d'échec d'allocation 
        // on peut appeler delete [] sans problème 
        try 
        { 
            this->tableau1 = new int[ A ]; 
            this->tableau2 = new int[ B ]; 
        } 
        catch ( const std::bad_alloc & ) 
        { 
            // tableau2 n'a pas été alloué quoi qu'il arrive 
            // libérer tableau1 s'il a pu être alloué 
            delete [] this->tableau1; 
            // relancer l'exception 
            throw; 
        } 
    } 
    ~Test() 
    { 
        delete [] this->tableau2; 
        delete [] this->tableau1; 
    } 
  
private: 
    int * tableau1; 
    int * tableau2; 
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
void f1() noexcept // Cette fonction ne lance pas d'exceptions 
{ 
  //... 
}  
 
void f2() noexcept(true) // Cette fonction non plus 
{ 
  //... 
}  
 
void f3() noexcept(noexcept(g) && noexcept(h)) // Cette fonction ne lance pas d'exceptions si g et h sont aussi déclarés noexcept 
{ 
  //... 
}

1
2
3
void Test() throw () 
{ 
}

1
2
3
4
5
6
7
8
9
10
char * buffer = new char[ 100 ]; 
try 
{ 
    // opération susceptible de lever une exception 
} 
finally 
{ 
    // s'assurer que la mémoire est libérée 
    delete [] buffer; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
char * buffer = new char[ 100 ]; 
try 
{ 
    // opération susceptible de lever une exception 
} 
catch ( ... ) 
{ 
    // éviter les fuites de mémoire 
    delete [] buffer; 
    // relancer l'exception 
    throw; 
} 
// tout s'est bien passé, libérer la mémoire 
delete [] buffer;