FAQ C++Consultez toutes les FAQ

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Test1 est exception safe sans utilisation de pointeur intelligent 
void Test1() 
{ 
    int * ptr = new int; 
    try 
    { 
        // code pouvant lever une exception 
    } 
    catch ( ... ) // gestion approximative... 
    { 
        // libérer le pointeur 
        delete ptr; 
        // relancer l'exception 
        throw; 
    } 
    // tout s'est bien passé, libérer la mémoire 
    delete ptr; 
}

1
2
3
4
5
6
7
8
9
10
#include <memory> // pour std::unique_ptr 
  
// Test2 est exception safe en utilisant un pointeur intelligent 
void Test2() 
{ 
    // std::unique_ptr est la classe pointeur intelligent standard 
    std::unique_ptr<int> smart_ptr = std::make_unique<int>(); 
  
    // code pouvant lever une exception (rien d'autre !) 
}

1
2
3
4
5
6
7
8
9
10
11
12
int Test()  
{  
    // ptr1 est le propriétaire 
    std::auto_ptr<int> ptr1( new int ); 
    { 
        // ptr2 devient le propriétaire 
        std::auto_ptr<int> ptr2 = ptr1; 
    } 
    // ici ptr2 est détruit, le int est libéré ! 
    // ptr1 pointe désormais vers NULL 
    *ptr1 = 10; // aïe aïe aïe... 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
include <memory>  
  
// Ptr est passé par valeur, donc a priori aucun risque que le 
// paramètre donné lors de l'appel ne soit modifié 
void Test( std::auto_ptr<MaClasse> Ptr )  
{  
    // Mais ce qui va réellement se passer, c'est que Ptr va prendre 
    // le contrôle de l'objet pointé, et le détruire à la fin de la fonction !  
}  
  
MaClasse* Ptr1 = new MaClasse;  
Test( std::auto_ptr<MaClasse>( Ptr1 ) );  
// Ici Ptr1 ne pointe plus sur une zone valide, il a été détruit suite à l'appel  
  
std::auto_ptr<MaClasse> Ptr2( new MaClasse );  
Test( Ptr2 );  
// Ici Ptr2 ne pointe plus sur la donnée originale 
// il pointe sur NULL et la donnée a été détruite dans la fonction