#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 !"
}

#define MAX_SIZE 100

void Exemple( void )
{
    char nom[ MAX_SIZE ];

    printf( "Veuillez entrer votre nom : " );
    fgets( stdin, nom, MAX_SIZE );
}

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

#include <string>

// construction
std::string str1 = "coucou";
std::string str2( "coucou" );
// affectation
std::string str3;
str3 = "coucou";
str3.assign( "coucou" );

string file_name = "fichier.txt";
// ouverture du fichier
ifstream file( file_name.c_str() ); // le constructeur de std::ifstream n'accepte pas de string

#include <string>
#include <cstring>
#include <iostream>

int main()
{
    using namespace std;

    string str = "une chaîne de caractères";
    // créer le buffer pour copier la chaîne
    size_t size = str.size() + 1;
    char * buffer = new char[ size ];
    // copier la chaîne
    strncpy( buffer, str.c_str(), size );
    // utiliser le buffer
    cout << buffer << '\n'; // "une chaîne de caractères" 
    // libérer la mémoire
    delete [] buffer;
}

#include <sstream>

int main()
{    
    // créer un flux de sortie
    std::ostringstream oss;
    // écrire un nombre dans le flux
    oss << 10;
    // récupérer une chaîne de caractères
    std::string result = oss.str();
}

#include <sstream>

int main()
{
    // créer un flux à partir de la chaîne à convertir
    std::istringstream iss( "10" );
    // convertir en un int
    int nombre;
    iss >> nombre; // nombre vaut 10
}

#include <sstream>  

template<typename T>
std::string to_string( const T & Value )
{
    // utiliser un flux de sortie pour créer la chaîne
    std::ostringstream oss;
    // écrire la valeur dans le flux
    oss << Value;
    // renvoyer une string
    return oss.str();
}

int main()
{    
    std::string num = to_string( 10 );
}

#include <sstream>  

template<typename T>
bool from_string( const std::string & Str, T & Dest )
{
    // créer un flux à partir de la chaîne donnée
    std::istringstream iss( Str );
    // tenter la conversion vers Dest
    return iss >> Dest != 0;
}

int main()
{    
    int dix;
    from_string( "10", dix );
}

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

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

istringstream s( "10" );
int n;
if ( s >> n )
{
}

istringstream s( "10" );
int n;
if ( s.operator >>( n ) )
{
}

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

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

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

string s = "abcba";

cout << s.find( "ba" ) << '\n'; // affiche 3
cout << s.find_first_of( "ba" ) << '\n'; // affiche 0

#include <string>
#include <iostream>

int main()
{
    std::wstring s = L"Chaîne unicode";
    wchar_t c = s[ 0 ]; // c = L'C'
    std::wcout << s;
}

namespace std
{
    typedef basic_string<char, char_traits<char>, allocator<char> > string;
}

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;

ci_string s1 = "salut";
ci_string s2 = "SAluT";

cout << (s1 == s2); // affiche "1" (vrai)

#include <cctype>    // pour tolower et toupper
#include <string>    // pour string
#include <iostream>  // pour cout
#include <algorithm> // pour transform

struct my_tolower
{ 
    char operator()(char c) const 
    {
        return std::tolower(static_cast<unsigned char>(c));
    } 
};

struct my_toupper
{ 
    char operator()(char c) const 
    {
        return std::toupper(static_cast<unsigned char>(c));
    } 
};

int main()
{
    std::string s("ABCDEF");

    std::transform(s.begin(), s.end(), s.begin(), my_tolower());
    std::cout << s; // affiche "abcdef"

    std::transform(s.begin(), s.end(), s.begin(), my_toupper());
    std::cout << s; // affiche "ABCDEF"

    return 0;
}

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

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

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

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

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

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

string s = 0;

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

#include <string>
#include <iostream>

int main()
{
    using namespace std;

    string file_name = "fichier.txt";

    size_t ext_pos = file_name.find_last_of( '.' );
    if ( ext_pos != string::npos )
    {
        // 3 manières d'extraire l'entension
        string ext1 = file_name.substr( ext_pos );
        string ext2( file_name, ext_pos );
        string ext3;
        ext3.assign( file_name, ext_pos, file_name.size() - ext_pos );

        // 3 manières d'extraire le nom
        string name1 = file_name.substr( 0, ext_pos );
        string name2( file_name, 0, ext_pos );
        string name3 = file_name;
        name3.resize( ext_pos );

        // remplacer le nom
        string file_name2 = file_name; // copie pour préserver l'original
        file_name2.replace( 0, ext_pos, "remplace" );

        // remplacer l'extension
        string file_name3 = file_name; // copie pour préserver l'original
        file_name3.replace( ext_pos + 1, file_name3.size() - 1, "dat" );

        // insérer un mot entre le nom du fichier et son extension
        string file_name4 = file_name; // copie pour préserver l'original
        file_name4.insert( ext_pos, "-modif" );

        // afficher les résultats
        cout << ext1 << '\n'; // ".txt"
        cout << ext2 << '\n'; // ".txt"
        cout << ext3 << '\n'; // ".txt"
        cout << name1 << '\n'; // "fichier"
        cout << name2 << '\n'; // "fichier"
        cout << name3 << '\n'; // "fichier"
        cout << file_name2 << '\n'; // "remplace.txt"
        cout << file_name3 << '\n'; // "fichier.dat"
        cout << file_name4 << '\n'; // "fichier-modif.txt"
    }
}

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