FAQ C++Consultez toutes les FAQ

1
2
std::cout << "coucou" << std::endl; 
std::cout << "coucou\n" << std::flush;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <ostream> 
#include <string> 
  
class MaClasse 
{ 
    friend std::ostream& operator <<(std::ostream&, const MaClasse&); 
  
private : 
  
    int Integer; 
    std::string String; 
}; 
  
std::ostream& operator <<(std::ostream& Stream, const MaClasse& Obj) 
{ 
    Stream << Obj.Integer << " " << Obj.String; 
    return Stream; // N'oubliez pas de renvoyer le flux, afin de pouvoir chaîner les appels 
} 
  
MaClasse Obj; 
std::cout << "Ma classe : " << Obj << std::endl;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <istream> 
#include <string> 
  
class MaClasse 
{ 
    friend std::istream& operator >>(std::istream&, MaClasse&); 
  
private : 
  
    int Integer; 
    std::string String; 
}; 
  
std::istream& operator >>(std::istream& Stream, MaClasse& Obj) 
{ 
    Stream >> Obj.Integer >> Obj.String; 
    return Stream; // N'oubliez pas de renvoyer le flux, afin de pouvoir chaîner les appels 
} 
  
MaClasse Obj; 
std::cin >> Obj;

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <sstream> 
#include <string> 
  
std::ostringstream oss;  
std::string Fichier[10];  
  
// Génère une suite de noms de fichiers numérotés de 0 à 9  
for (int i = 0; i < 10; ++i)  
{  
    oss.str("");  
    oss << "Image_" << i << ".bmp";  
    Fichier[i] = oss.str();  
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <algorithm> 
#include <iomanip> 
#include <sstream> 
#include <string> 
  
std::string array_to_string(const unsigned char* buffer, std::size_t size) 
{ 
    std::ostringstream oss; 
  
    // Afficher en hexadécimal et en majuscule 
    oss << std::hex << std::uppercase; 
  
    // Injecter tous les caractères sous forme d'entiers dans le flux 
    std::copy(buffer, buffer + size, std::ostream_iterator<int>(oss, "")); 
  
    return oss.str(); 
}

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
#include <algorithm> 
#include <iomanip> 
#include <sstream> 
#include <string> 
  
std::string array_to_string(const unsigned char* buffer, std::size_t size) 
{ 
    std::ostringstream oss; 
  
    // Afficher en hexadécimal et en majuscule 
    oss << std::hex << std::uppercase; 
  
    // Remplir les blancs avec des zéros 
    oss << std::setfill('0'); 
  
    for (std::size_t i = 0; i < size; ++i) 
    { 
        // Séparer chaque octet par un espace 
        if (i != 0) 
            oss << ' '; 
  
        // Afficher sa valeur hexadécimale précédée de "0x" 
        // setw(2) permet de forcer l'affichage à 2 caractères 
        oss << "0x" << std::setw(2) << static_cast<int>(buffer[i]); 
    } 
  
    return oss.str(); 
} 
  
int main() 
{ 
    const std::size_t size = 5; 
    const unsigned char data[size] = {0x0C, 0x10, 0xFF, 0x00, 0xDA}; 
    std::cout << array_to_string(data, size) << '\n'; 
}

1
2
3
4
5
// Récupérer le streambuf d'un flux 
std::streambuf* std::ios::rdbuf(); 
  
// Changer le streambuf d'un flux 
void std::ios::rdbuf(std::streambuf*);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <fstream> 
#include <iostream> 
  
int main() 
{ 
    std::cout << "Affichage sur la console"<< std::endl; 
  
    // Redirection de std::cout vers le fichier Toto.txt 
    std::ofstream Out("Toto.txt"); 
    std::streambuf* OldBuf = std::cout.rdbuf(Out.rdbuf()); 
  
    std::cout << "Affichage dans Toto.txt"<< std::endl; 
  
    // Restauration du streambuf initial de std::cout (affichage sur la console) 
    std::cout.rdbuf(OldBuf); 
  
    return 0; 
}

1
2
3
4
5
6
7
std::vector<int> Tab; 
Tab.push_back(1); 
Tab.push_back(3); 
Tab.push_back(6); 
  
// Plus besoin de boucle pour afficher les éléments du tableau : 
std::copy(Tab.begin(), Tab.end(), std::ostream_iterator<int>(std::cout, "\n"));

1
2
3
4
5
6
7
8
9
10
// On va extraire à partir d'un fichier, par exemple 
std::ifstream File("Data.txt"); 
  
// Méthode 1 : std::copy 
std::vector<MaClasse> Tab1; 
std::copy(istream_iterator<MaClasse>(File), istream_iterator<MaClasse>(), std::back_inserter(Tab1)); 
// std::back_inserter va remplacer les affectations par des push_back 
  
// Méthode 2 : utiliser le constructeur prenant une paire d'itérateurs 
std::vector<MaClasse> Tab2(istream_iterator<MaClasse>(File), (istream_iterator<MaClasse>()));

1
2
3
istream_iterator<MaClasse> Begin(File); 
istream_iterator<MaClasse> End; 
std::vector<MaClasse> Tab2(Begin, End);

1
2
3
4
5
istringstream s( "10" ); 
int n; 
if ( s >> n ) 
{ 
}

1
2
3
4
5
istringstream s( "10" ); 
int n; 
if ( s.operator >>( n ) ) 
{ 
}

1
2
3
4
5
istringstream s( "10" ); 
int n; 
if ( s.operator >>( n ).operator void*() != 0 ) 
{ 
}