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
56
57
58
59
60
61
#include <iostream> 
#include <string> 
#include <boost/shared_ptr.hpp> 
  
class Test 
{ 
public: 
    Test( const char * Name ): 
        name( Name ) 
    { 
    } 
  
    ~Test() 
    { 
        std::cout << "Destruction de " << this->name << '\n';  
    } 
  
    void printName() 
    {  
        std::cout << this->name << '\n';  
    } 
  
private: 
    std::string name; 
}; 
  
// déclaration du type pointeur intelligent sur Test 
typedef boost::shared_ptr<Test> TestPtr; 
  
int main() 
{ 
    TestPtr ptr; // pointeur initialisé à NULL 
  
    { 
        // pointeur temporaire détruit à la fin du bloc 
        TestPtr ptr_tmp( new Test( "objet1" ) ); 
  
        // initialiser ptr avec ptr_tmp 
        ptr = ptr_tmp; 
    } // ici, ptr_tmp est détruit, mais ptr reste valide 
  
    ptr->printName(); // OK, affiche "objet1" 
  
    // réinitialiser le pointeur avec un nouvel objet 
    // objet1 est détruit, objet2 est créé 
    ptr.reset( new Test( "objet2" ) ); 
  
    ptr->printName(); // OK, affiche "objet2" 
  
    // copie du pointeur sur objet2 
    TestPtr ptr2 = ptr; 
  
    // mise à NULL de ptr 
    ptr.reset(); // rien ne se passe 
  
    // mise à NULL de ptr2 
    ptr2.reset(); // objet2 est détruit 
  
    // utilisation du pointeur NULL : erreur en mode Debug 
    ptr->printName(); // Assertion failed: px != 0 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
struct Delete 
{ 
    void operator ()(Test*& Ptr) const 
    { 
        cout << "Destruction"; 
        delete Ptr; 
    } 
}; 
  
int main() 
{ 
    shared_ptr<Test> Ptr(new Test(), Delete()); 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <boost/shared_ptr.hpp> 
  
class Base 
{ 
public: 
    virtual ~Base() {}; 
}; 
  
class Derived : public Base {}; 
  
typedef boost::shared_ptr<Base> BasePtr; 
typedef boost::shared_ptr<const Base> BaseConstPtr; 
typedef boost::shared_ptr<Derived> DerivedPtr; 
typedef boost::shared_ptr<const Derived> DerivedConstPtr;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void implicit_upcasting() 
{ 
// casting implicite sur des pointeurs bruts 
{     
    Derived *d = new Derived; 
    Base *b1 = d; 
    const Base *b2 = d; 
    delete d; 
} 
// équivalent avec des pointeurs intelligents 
{     
    DerivedPtr d( new Derived ); 
    BasePtr b1 = d; 
    BaseConstPtr b2 = d; 
} 
}

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
void down_casting() 
{ 
// downcasting sur des pointeurs bruts 
{ 
    Base *b = new Derived; 
    Derived *d1 = static_cast<Derived*>( b ); 
    Derived *d2 = dynamic_cast<Derived*>( b ); 
    assert( d2 != 0 ); 
    delete b; 
} 
// équivalent avec des pointeurs intelligents 
{ 
    BasePtr b( new Derived ); 
    DerivedPtr d1 = boost::static_pointer_cast<Derived>( b ); 
    DerivedPtr d2 = boost::dynamic_pointer_cast<Derived>( b ); 
    assert( d2 != 0 ); 
} 
} 
  
void const_casting() 
{     
// constcasting sur des pointeurs bruts 
{ 
    const Base *b_const = new Base; 
    Base *b2 = const_cast<Base*>( b_const ); 
    delete b_const; 
} 
// équivalent avec des pointeurs intelligents 
{ 
    BaseConstPtr b_const( new Base ); 
    BasePtr b2 = boost::const_pointer_cast<Base>( b_const ); 
} 
}

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
void deprecated_casting() 
{         
// downcasting sur des pointeurs bruts 
{ 
    Base *b = new Derived;     
    try 
    {         
        // downcasting levant std::bad_cast en cas d'échec 
        Derived &d1 = dynamic_cast<Derived&>( *b );         
    } 
    catch ( const std::bad_cast & )  
    { 
    } 
    // downcasting provoquant une erreur uniquement en debug 
#ifdef _DEBUG 
    Derived *d2 = dynamic_cast<Derived*>( b ); 
    assert( d2 ); 
#else 
    Derived *d2 = static_cast<Derived*>( b ); 
#endif 
    delete b; 
} 
// équivalent avec des pointeurs intelligents 
{ 
    BasePtr b( new Derived ); 
    try 
    {         
        // downcasting levant std::bad_cast en cas d'échec 
        DerivedPtr d1 = boost::shared_polymorphic_cast<Derived>( b );         
    } 
    catch ( const std::bad_cast & ) 
    { 
    } 
    // downcasting provoquant une erreur uniquement en debug 
    DerivedPtr d2 = boost::shared_polymorphic_downcast<Derived>( b ); 
} 
}

1
2
3
std::auto_ptr<int> p1( new int ); 
boost::shared_ptr<int> p2( p1 ); 
// ici, p1 est invalide

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
#include <iostream> 
#include <boost/tokenizer.hpp> 
  
// découpe la chaine avec les séparateurs par défaut 
void split( const std::string & Msg ) 
{ 
    // utiliser le tokenizer par défaut 
    boost::tokenizer<> tok( Msg ); 
  
    // itérer la séquence de tokens 
    for ( boost::tokenizer<>::const_iterator i = tok.begin(); 
          i != tok.end(); 
          ++i ) 
    { 
        // afficher chaque token extrait 
        std::cout << *i << '\n'; 
    } 
} 
  
// découpe la chaine selon les séparateurs donnés 
void split( const std::string & Msg, const std::string & Separators ) 
{ 
    // typedef pour alléger l'écriture 
    typedef boost::tokenizer<boost::char_separator<char> > my_tok; 
  
    // séparateur personnalisé 
    boost::char_separator<char> sep( Separators.c_str() ); 
  
    // construire le tokenizer personnalisé 
    my_tok tok( Msg, sep ); 
  
    // itérer la séquence de tokens 
    for ( my_tok::const_iterator i = tok.begin(); 
          i != tok.end(); 
          ++i ) 
    { 
        // afficher chaque token extrait 
        std::cout << *i << '\n'; 
    } 
} 
  
int main() 
{ 
    std::cout << "-- exemple 1 --\n"; 
  
    split( "mot1;mot2;   ;mot3;;mot4;mot5;" ); 
  
    std::cout << "-- exemple 2 --\n"; 
  
    split( "mot-compose1;mot,compose2;[mot][compose3];mot compose4;<mot><compose><5>", ";" ); 
}

1
2
3
4
5
6
7
8
9
10
11
12
-- exemple 1 -- 
mot1 
mot2 
mot3 
mot4 
mot5 
-- exemple 2 -- 
mot-compose1 
mot,compose2 
[mot][compose3] 
mot compose4 
<mot><compose><5>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <list> 
#include <algorithm> 
#include <boost/checked_delete.hpp> 
  
int main()  
{  
    // Création d'une liste de pointeurs  
    std::list<int*> l;  
    l.push_back(new int(5));  
    l.push_back(new int(0));  
    l.push_back(new int(1));  
    l.push_back(new int(6));  
  
    // Destruction de la liste : attention il faut bien libérer les pointeurs avant la liste !  
    std::for_each(l.begin(), l.end(), boost::checked_deleter<int>());  
  
    return 0;  
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <list> 
#include <algorithm> 
#include <boost/foreach.hpp> 
  
int main()  
{  
    // Création d'une liste de pointeurs  
    std::list<int*> l;  
    l.push_back(new int(5));  
    l.push_back(new int(0));  
    l.push_back(new int(1));  
    l.push_back(new int(6));  
  
    // Destruction de la liste : attention il faut bien libérer les pointeurs avant la liste ! 
    BOOST_FOREACH( int *pi, l ) 
    { 
       delete pi; 
    } 
  
    return 0;  
}

1
2
3
4
5
6
7
8
9
10
11
12
class A { };  
class B { };  
class C {}; 
class D {}; 
  
boost::variant<A,B,C,D,std::string,int> v; 
v = A(); // v contient une valeur de type A 
v = B(); // v contient une valeur de type B 
v = C(); // v contient une valeur de type C 
v = D(); // v contient une valeur de type D 
v = "Salut"; // v contient une valeur de type std::string 
v = 42; // v contient une valeur de type int

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
struct Op 
{ 
  enum op_type { ADD, SUB }; 
  
  double e1, e2; 
  op_type op; 
}; 
  
double compute_op(const Op& o) 
{ 
  switch(o.op) 
  { 
    case Op::ADD: 
    return o.e1 + o.e2; break; 
    case Op::SUB: 
    return o.e1 - o.e2; break; 
  } 
} 
  
typedef boost::variant<double, Op> expression; 
  
double compute_expression(const expression& e) 
{ 
  if( double* d = boost::get<double>(&e) ) 
  { 
    return d; 
  } 
  Op* o = boost::get<Op>(&e); 
  return compute_op(*o); 
}

1
2
3
4
5
6
7
8
template<typename U, typename T1, typename T2, ..., typename TN>  
  U * get(variant<T1, T2, ..., TN> * operand); // (1) 
template<typename U, typename T1, typename T2, ..., typename TN>  
  const U * get(const variant<T1, T2, ..., TN> * operand); // (2) 
template<typename U, typename T1, typename T2, ..., typename TN>  
  U & get(variant<T1, T2, ..., TN> & operand); // (3) 
template<typename U, typename T1, typename T2, ..., typename TN>  
  const U & get(const variant<T1, T2, ..., TN> & operand); // (4)

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
#include <iostream> 
#include <boost/variant.hpp> 
  
int main() 
{ 
  boost::variant<int, std::string> v; 
  v = 42; 
  
  int* i = boost::get<int>(&v); // l'entier pointé par i vaut 42. 
  assert(*i == 42); 
  *i = 84; // cela a également modifié la valeur contenue dans v 
  std::string* s = boost::get<std::string>(&v); 
  assert(s == NULL); // s vaut effectivement le pointeur nul 
  
  int& i2 = boost::get<int>(v); 
  assert(i2 == 84); 
  try 
    { 
      std::string& s = boost::get<std::string>(v); 
    } 
  catch (std::exception& e) 
    { 
      std::cout << "Exception ! " << e.what() << std::endl; 
    } 
  return 0; 
}

1
2
3
4
boost::variant< int, string > x; // déclare une variable de type boost::variant en précisant les types autorisés. 
x = 42; //x contient un entier  
x = "hello, world"; // x contient une chaine de caractères 
x = new Widget(); //erreur, x ne peut pas contenir un Widget.

1
2
3
4
boost::any x; 
x = 42; // x contient un entier 
x = "hello, world"; //x contient une chaine de caractères  
x = new Widget(); // x contient un widget, pas d'erreur