FAQ C++Consultez toutes les FAQ

1
2
3
4
5
6
7
8
9
10
#include <iostream> // pour std::cout 
#include <string>   // pour std::string 
  
int main() 
{ 
    std::string message = "Hello"; // création de la chaîne "Hello" 
    message += " World !";         // concaténation de " Word !" 
  
    std::cout << message << '\n';  // affichage de "Hello World !" 
}

1
2
3
4
5
6
7
8
9
#define MAX_SIZE 100 
  
void Exemple( void ) 
{ 
    char nom[ MAX_SIZE ]; 
  
    printf( "Veuillez entrer votre nom : " ); 
    fgets( stdin, nom, MAX_SIZE ); 
}

1
2
3
4
5
6
7
8
9
10
11
12
void Exemple() 
{ 
    try 
    { 
        // effectuer une allocation 
    } 
    catch ( std::bad_alloc & ) 
    { 
        // ATTENTION : utiliser std::string ou tout autre conteneur standard 
        // peut déclencher une nouvelle exception std::bad_alloc 
    } 
}

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
#include <string> 
#include <iostream> 
  
int main() 
{ 
    using namespace std; 
  
    string s; // la chaîne est vide 
    cout << "size = " << s.size() << '\t'  // size = 0  
         << "capacity = " << s.capacity()  // capacity = 15 
         << '\n'; 
  
    // on sait que l'on va faire de nombreuses concaténations, 
    // alors on réserve de l'espace pour éviter de multiples allocations 
    s.reserve( 26 ); 
    cout << "size = " << s.size() << '\t'  // size = 0  
         << "capacity = " << s.capacity()  // capacity = 31 
         << '\n'; 
  
    // concaténer les 26 lettres de l'alphabet 
    for ( char c = 'A'; c <= 'Z'; ++c ) 
    { 
        s += c; 
    } 
  
    cout << "size = " << s.size() << '\t'  // size = 26  
         << "capacity = " << s.capacity()  // capacity = 31 
         << '\n'; 
  
    s = "une assez longue chaîne qui oblige a faire une allocation"; 
    cout << "size = " << s.size() << '\t'  // size = 57 
         << "capacity = " << s.capacity()  // capacity = 63 
         << '\n'; 
}

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 <string> 
  
int main() 
{ 
    using std::string; 
  
    string str( "Hello" ); 
    const char * c_str = str.c_str(); // ok 
  
    // erreur 1 : invalidation de pointeur suite à une modification 
    str += " World !"; // concaténer " World !" à "Hello" 
    // maintenant c_str est invalide, et ne doit plus être utilisé ! 
  
    c_str = str.c_str(); 
    // erreur 2 : l'utilisation de [] peut aussi invalider c_str 
    char c = str[ 0 ]; // ok, accès en lecture seulement 
    str[ 0 ] = 'A'; // modification d'un caractère 
    // maintenant c_str est invalide, et ne doit plus être utilisé ! 
  
    // erreur 3 : invalidation de pointeur suite à une destruction 
    { 
        // variable temporaire à ce bloc 
        string str2( "Temporaire" ); 
        c_str = str2.c_str(); // ok 
    } // fin du bloc : str2 est détruite 
    // maintenant c_str est invalide car la chaîne pointée a été détruite !     
}

1
2
3
4
5
string s = "abcdef"; 
if ( s.find( 'c' ) == s.find_first_of( 'c' ) ) 
{ 
    // ce test est vrai 
}

1
2
3
4
string s = "abcba"; 
  
cout << s.find( "ba" ) << '\n'; // affiche 3 
cout << s.find_first_of( "ba" ) << '\n'; // affiche 0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <sstream>   
  
bool is_float( const std::string & Str ) 
{ 
    // créer un flux à partir de la chaîne donnée 
    std::istringstream iss( Str ); 
    // créer un objet temporaire pour la conversion 
    float tmp; 
    // tenter la conversion et 
    // vérifier qu'il ne reste plus rien dans la chaîne 
    return ( iss >> tmp ) && ( iss.eof() ); 
} 
  
int main() 
{ 
    is_float( "10.0" ); // vrai 
    is_float( "abcd" ); // faux 
    is_float( "10.0abcd" ); // faux grâce au 2° test 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <sstream>   
  
template<typename T> 
bool is_of_type( const std::string & Str ) 
{ 
    // créer un flux à partir de la chaîne donnée 
    std::istringstream iss( Str ); 
    // créer un objet temporaire pour la conversion 
    T tmp; 
    // tenter la conversion et 
    // vérifier qu'il ne reste plus rien dans la chaîne 
    return ( iss >> tmp ) && ( iss.eof() ); 
} 
  
int main() 
{ 
    is_of_type<float>( "10.5" ); // vrai 
    is_of_type<int>( "10.5" ); // faux grâce au 2° test 
}

1
2
3
4
namespace std 
{ 
    typedef basic_string<char, char_traits<char>, allocator<char> > string; 
}

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
struct ci_char_traits : public std::char_traits<char> 
// on dérive du char_traits par défaut, ainsi on hérite des fonctions que nous ne voulons pas redéfinir 
{ 
    static bool eq(char c1, char c2) 
    { 
        return toupper(c1) == toupper(c2); 
    } 
  
    static bool ne(char c1, char c2) 
    { 
        return toupper(c1) != toupper(c2); 
    } 
  
    static bool lt(char c1, char c2) 
    { 
        return toupper(c1) < toupper(c2); 
    } 
  
    static int compare(const char* s1, const char* s2, size_t n) 
    { 
        return memicmp(s1, s2, n); // si disponible sur votre compilateur 
    } 
  
    static const char* find(const char* s, int n, char a) 
    { 
        while ((n-- > 0) && (toupper(*s) != toupper(a))) 
            ++s; 
  
        return s; 
    } 
};

typedef std::basic_string<char, ci_char_traits> ci_string;

1
2
3
4
ci_string s1 = "salut"; 
ci_string s2 = "SAluT"; 
  
cout << (s1 == s2); // affiche "1" (vrai)

1
2
3
4
5
6
7
8
9
10
#include <algorithm> // pour std::reverse() 
#include <string>  
  
std::string chaine = "Bonjour";  
  
// Inversion directe de la chaîne  
std::reverse(chaine.begin(), chaine.end());  
  
// Autre méthode : création d'une chaîne inversée  
std::string inverse( chaine.rbegin(), chaine.rend() );

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <sstream> 
#include <string> 
#include <iostream> 
  
using namespace std; 
  
int main() 
{ 
    istringstream iss( "mot1;mot2;mot3;mot4" ); 
    string mot; 
    while ( std::getline( iss, mot, ';' ) ) 
    { 
        cout << mot << '\n'; 
    } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// fonctions de traitement 
void parametre_input(); 
void parametre_output(); 
void parametre_inconnu(); 
  
// appel des fonctions de traitement 
void analyse_parametre( const char * Param ) 
{ 
    switch ( Param ) 
    { 
    case "/input": 
        parametre_input(); break; 
  
    case "/output": 
        parametre_output(); break; 
  
    default: 
        parametre_inconnu(); 
    } 
}

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
// fonctions de traitement 
void parametre_input(); 
void parametre_output(); 
void parametre_inconnu(); 
  
// type pointeur de fonction de traitement 
typedef void (*parametre_fct)(); 
  
void analyse_parametre( const string & Param ) 
{ 
    static map<string, parametre_fct> param_map; 
  
    // initialiser la map si ce n'est pas fait 
    if ( param_map.empty() ) 
    { 
        param_map[ "/input" ] = parametre_input; 
        param_map[ "/output" ] = parametre_output; 
    } 
  
    // rechercher la fonction associée à Param 
    map<string, parametre_fct>::const_iterator i = param_map.find( Param ); 
    if ( i == param_map.end() ) 
    { 
        // échec 
        parametre_inconnu(); 
    } 
    else 
    { 
        // appeler la fonction associée 
        (i->second)(); 
    } 
}

1
2
3
4
5
6
7
8
9
#include <string> 
#include <iostream> 
  
int main() 
{ 
    std::wstring s = L"Chaîne unicode"; 
    wchar_t c = s[ 0 ]; // c = L'C' 
    std::wcout << s; 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <string> 
#include <locale> 
#include <vector> 
  
std::string narrow(const std::wstring& ws) 
{ 
    std::vector<char> buffer(ws.size()); 
    std::locale loc("english"); 
    std::use_facet< std::ctype<wchar_t> >(loc).narrow(ws.data(), ws.data() + ws.size(), '?', &buffer[0]); 
  
    return std::string(&buffer[0], buffer.size()); 
} 
  
std::wstring widen(const std::string& s) 
{ 
    std::vector<wchar_t> buffer(s.size()); 
    std::locale loc("english"); 
    std::use_facet< std::ctype<wchar_t> >(loc).widen(s.data(), s.data() + s.size(), &buffer[0]); 
  
    return std::wstring(&buffer[0], buffer.size()); 
}

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
#include <string>  
#include <algorithm> // remove(), erase() 
#include <iostream>  
  
// supprime toutes les occurrences du caractère C donné 
void SupprimeTousLesCaracteres( std::string & Str, char C ) 
{  
    Str.erase( 
        std::remove( Str.begin(), Str.end(), C ), 
        Str.end() );  
}     
  
// supprime tous les caractères C situés au début de Str 
std::string SupprimeLesPremiersCaractères( const std::string & Str, char C ) 
{  
   return Str.substr( 
       Str.find_first_not_of( C ) );  
}  
  
int main() 
{  
    using namespace std; 
  
    // supprimer les quote entre les mots 
    string s1 = "'mot1' 'mot2' 'mot3' 'mot4'"; 
    SupprimeTousLesCaracteres( s1, '\'' ); 
    cout << s1 << '\n'; // affiche "mot1 mot2 mot3 mot4" 
  
    // enlever les espaces gênants au début de la chaîne 
    string s2 = "     exemple";  
    cout << SupprimeLesPremiersCaractères( s2, ' ' ); // affiche "exemple" 
}

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
#include <vector> 
#include <sstream> 
#include <iostream> 
#include <iterator> 
  
int main() 
{ 
    using namespace std; 
  
    string str = "mot1 mot2 mot3 mot4 mot5 mot6"; 
  
    vector<string> str_list; // liste de mots 
  
    // remplir la liste de mots 
    istringstream iss( str ); 
    copy( 
        istream_iterator<string>( iss ), 
        istream_iterator<string>(), 
        back_inserter( str_list ) ); 
  
    // afficher la liste de mots sur cout 
    copy( 
        str_list.begin(), 
        str_list.end(), 
        ostream_iterator<string>( cout, "\n" ) ); 
  
    // reconstituer une string à partir de la liste de mots 
    ostringstream oss; 
    copy( 
        str_list.begin(), 
        str_list.end(), 
        ostream_iterator<string>( oss, " " ) ); 
  
    string s = oss.str(); 
    cout << s << '\n'; // "mot1 mot2 mot3 mot4 mot5 mot6" 
}