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

#include <iostream>
#include <string> 

std::string chaine; 
std::getline( std::cin, chaine );

#include <string> 
#include <sstream> 

int x = 127; 
std::ostringstream oss; 
oss << std::hex << x; 

std::string Hex = oss.str();

#include <string> 
#include <sstream> 

std::string Hex = "7F"; 
int x; 

std::istringstream iss( Hex ); 
iss >> std::hex >> x;

#include <bitset>
#include <string>
#include <sstream>

int main()
{
    // Conversion binaire -> décimal
    std::bitset<8> b1( std::string( "01001011" ) );
    unsigned long x = b1.to_ulong(); // x = 75

    // Conversion décimal -> binaire
    std::bitset<8> b2( 75 );

    // Version 1 : un peu lourde à écrire
    std::string s1 = b2.to_string<
        char,
        std::char_traits<char>,
        std::allocator<char> >(); // s1 = "01001011"

    // Version 2 : un peu plus sympa
    std::ostringstream oss;
    oss << b2;
    std::string s2 = oss.str(); // s2 = "01001011"
}

#include <iomanip>
#include <iostream>

using namespace std;

// Un petit tableau

// En-têtes de colonnes
cout << setfill(' ')
     << setw(15) << left << "Colonne 1"
     << setw(10) << left << "Colonne 2"
     << endl;

// Ligne 1
cout << setprecision(2) << fixed
     << setw(15) << left << 158.82589
     << setw(10) << left << 456.10288
     << endl;

// Ligne 2
cout << hex << uppercase
     << setw(15) << left << 255
     << setw(10) << left << 128
     << endl;

// Ligne 3
cout << boolalpha
     << setw(15) << left << true
     << setw(10) << left << false
     << endl;

#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;

#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;

#include <iostream> 

class Base 
{ 
    friend std::ostream& operator << (std::ostream& O, const Base& B); 

    virtual void Print(std::ostream& O) const 
    { 
        O << "Je suis une base"; 
    } 
}; 

class Derivee : public Base 
{ 
    virtual void Print(std::ostream& O) const 
    { 
        O << "Je suis une derivee"; 
    } 
}; 

std::ostream& operator << (std::ostream& O, const Base& B) 
{ 
    B.Print(O); 
    return O; 
} 

Base* B1 = new Base, 
Base* B2 = new Derivee; 

std::cout << *B1 << std::endl; // "Je suis une base" 
std::cout << *B2 << std::endl; // "Je suis une derivee"

#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(); 
}

#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();
}

#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';
}

0x0C 0x10 0xFF 0x00 0xDA

// 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*);

#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;
}

>MonProgramme.exe > Toto.txt

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"));

// 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>()));

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