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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
#include <iostream> 
#include <vector> 
#include <algorithm> 
#include <numeric> 
  
  
int main() 
{ 
    using std::cout; 
  
    // créer un tableau d'entiers, vide 
    std::vector<int> v; 
  
    // ajouter l'entier 10 à la fin 
    v.push_back( 10 ); 
  
    // afficher le premier élément (10) 
    cout << v.front() << '\n'; 
  
    // afficher le dernier élément (10) 
    cout << v.back() << '\n'; 
  
    // enlever le dernier élément 
    v.pop_back(); // supprime '10' 
  
    // le tableau est vide 
    if ( v.empty() ) 
    { 
        cout << "Tout est normal : tableau vide\n"; 
    } 
  
    // redimensionner le tableau 
    // resize() initialise tous les nouveaux entiers à 0 
    v.resize( 10 ); 
  
    // quelle est sa nouvelle taille ? 
    cout << v.size() << '\n'; // affiche 10 
  
    // sa taille est de 10 : on peut accéder directement aux 
    // 10 premiers éléments 
    v[ 9 ] = 5; 
  
    // initialiser tous les éléments à 100 
    std::fill( v.begin(), v.end(), 100 ); 
  
    // vider le tableau 
    v.clear(); // size() == 0 
  
    // on va insérer 50 éléments 
    // réserver (allouer) de la place pour au moins 50 éléments 
    v.reserve( 50 ); 
  
    // vérifier que la taille n'a pas bougée (vide) 
    cout << v.size() << '\n'; 
  
    // capacité du tableau = nombre d'éléments qu'il peut stocker 
    // sans devoir réallouer (modifié grâce à reserve()) 
    cout << v.capacity() << '\n'; // au moins 50, sûrement plus 
  
    for ( int i = 0; i < 50; ++i ) 
    { 
        // grâce à reserve() on économise de multiples réallocations 
        // du fait que le tableau grossit au fur et à mesure 
        v.push_back( i ); 
    } 
  
    // afficher la nouvelle taille 
    cout << v.size() << '\n'; // affiche 50 
  
    // rechercher l'élément le plus grand (doit être 49) 
    cout << *std::max_element( v.begin(), v.end() ) << '\n'; 
  
    // tronquer le tableau à 5 éléments 
    v.resize( 5 ); 
  
    // les trier par ordre croissant 
    std::sort( v.begin(), v.end() ); 
  
    // parcourir le tableau 
    for ( size_t i = 0, size = v.size(); i < size; ++i ) 
    { 
        // attention : utilisation de l'opérateur [] 
        // les accès ne sont pas vérifiés, on peut déborder ! 
        cout << v[ i ] << '\t';         
    } 
    cout << '\n'; 
  
    // utilisation de at() : les accès sont vérifiés 
    try 
    { 
        v.at( v.size() ) = 10; // accès en dehors des limites ! 
    } 
    catch ( const std::out_of_range & ) 
    { 
        cout << "at() a levé une exception std::out_of_range\n"; 
    } 
  
    // parcours avec un itérateur en inverse 
    for ( std::vector<int>::reverse_iterator i = v.rbegin(); 
          i != v.rend(); 
          ++i ) 
    { 
        cout << *i << '\t'; 
    } 
    cout << '\n'; 
  
    // on crée un tableau v2 de taille 10 
    std::vector<int> v2( 10 ); 
    v2.at( 9 ) = 5; // correct, le tableau est de taille 10 
  
    // on crée un tableau v3 de 10 éléments initialisés à 20 
    std::vector<int> v3( 10, 20 ); 
  
    // faire la somme de tous les éléments de v3 
    // on doit obtenir 200 (10 * 20) 
    cout << std::accumulate( v3.begin(), v3.end(), 0 ) << '\n'; 
  
    // on recopie v3 dans v 
    v = v3; 
  
    // on vérifie la recopie 
    if ( std::equal( v.begin(), v.end(), v3.begin() ) ) 
    { 
        cout << "v est bien une copie conforme de v3\n"; 
    } 
}

1
2
3
4
5
6
7
8
std::vector<int> v; 
for (std::vector<int>::iterator it = v.begin(); it != v.end(); ) 
{ 
    if (*it == 5) 
        it = v.erase(it); 
    else 
        ++it; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <string> 
#include <vector> 
#include <algorithm> 
  
int main() { 
    std::string s = "blah blah"; 
    s.erase(std::remove(s.begin(), s.end(), 'h'), s.end()); 
    // s = "bla bla" 
  
    std::vector<int> v {1, 3, 5, 7, 9, 11}; 
    v.erase(std::remove_if(v.begin(), v.end(), [](int value) { return value > 3; }), v.end()); 
    // v = {1, 3} 
}

1
2
3
4
5
6
7
8
9
10
#include <list> 
  
int main() { 
    std::list<int> l {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; 
    l.remove(5); 
    // l = {1, 2, 3, 4, 6, 7, 8, 9, 10} 
  
    l.remove_if([](int value) { return value > 3; }); 
    // l = {1, 2, 3} 
}

1
2
3
4
5
6
7
8
9
10
11
12
#include <map> 
#include <string> 
  
int main () { 
    std::unordered_map<std::string, int> m { 
        {"un",    1}, 
        {"deux",  2}, 
        {"trois", 3} 
    }; 
    m.erase("deux"); 
    // m = { {"un", 1}, {"trois", 3} } 
}

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
#include <list>  
#include <algorithm> 
  
// Foncteur servant à libérer un pointeur - applicable à n'importe quel type 
struct Delete  
{  
   template <class T> void operator ()(T*& p) const  
   {  
      delete p; 
      p = NULL; 
   }  
};  
  
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(), Delete());  
  
   return 0;  
}