La classe string se trouve dans l’espace de noms std . Il faut donc l’inclure au début de vos programmes :

(1)

Classe <string> de STL :

La classe string se trouve dans l’espace de noms std . Il faut donc l’inclure au début de vos programmes :

#include <string>

using namespace std ;

Voir les exemples string0.cpp et

string1.cpp sur le site Web du cours.

Pour la liste complète des méthodes de la classe string , visitez le site :

www.cppreference.com

(2)

Constructeurs

Syntaxe:

string();

Constructeur par défaut : construit une chaîne vide.

string chaineVide ; //Une chaîne vide est construite.

Syntaxe:

string( size_type nbCars, char car );

Construit une chaîne contenant "nbCars" caractères "car".

string chaine(4 , ‘A’);

cout<<chaine<<endl; // Affiche AAAA

Syntaxe:

string( const char *str );

Construit une chaîne à partir d’une chaine classique "str" du langage C.

const char* chaineClassique = "ABCDEF";

string str(chaineClassique);

cout<<str<<endl; //Affiche ABCDEF

Syntaxe:

string( const char *str, size_type longueur );

Construit une chaîne qui contient "longueur" caractères de "str" . Si

"longueur" dépasse le nombre de caractères de "str" , la chaîne construite contiendra tous les caractères de "str".

//Condition préalable : longueur >= 0

(3)

const char* chaineClassique = "ABCDEF";

string str1(chaineClassique , 3);

string str2(chaineClassique , 99);

cout<<str1<<endl;//Affiche ABC cout<<str2<<endl;/Affiche ABCDEF

Syntaxe:

string( string &str, size_type index, size_type longueur );

Construit une chaîne qui contient "longueur" caractères de "str" , à partir de l’indice "index" .

Si le nombre de caractères de "str" , à partir de l’indice "index" est inférieur à

"longueur" , la chaîne construite contiendra le reste de la chaîne "str" , à partir de l’indice "index".

Condition préalable : 0 <= index <= str.size() et longueur >=0

const string str = "ABCDEF";

string str1(str , 0, 3);

string str2(str , 4 , 99);

cout<<str1<<endl;//Affiche ABC cout<<str2<<endl;/Affiche EF

Syntaxe:

string( input_iterator debut, input_iterator fin );

Construit une chaîne qui contient les caractères compris entre les itérateurs debut et fin .

string str = "ABCDEF";

string str1(str.begin() , str.end());

string str2(str.begin() , str.begin()+2);

cout<<str1<<endl;//Affiche ABCCDEF cout<<str2<<endl;//Affiche AB

Opérateurs

(4)

Syntaxe:

==

>

<

>=

<=

!=

+ +=

[]

Voici des exemples qui montrent l’utilisation des ces opérateurs surchargés dans la classe string :

string str1("BONJOUR ");

string str2("TOUT ");

string str3(" LE MONDE");

cout<<(str1 == str2 ? "str1 == str2" :"str1 différente de str2 ")<<endl;

cout<<(str1 != str2 ? "str1 != str2" :"str1 identique à str2 ")<<endl;

cout<<(str1 > str2 ? "str1 > str2" :"str1 <= str2 ")<<endl;

cout<<str1[3]<<endl;

str1 = str1+str2;

cout<<str1<<endl ; str1 += str3;

cout<<str1<<endl ;

On obtient en sortie : str1 différente de str2 str1 != str2

str1 <= str2 J

(5)

BONJOUR TOUT

BONJOUR TOUT LE MONDE.

append

Syntaxe:

basic_string &append( const basic_string &str );

Ajoute le contenu de la chaîne str à la fin de la chaîne courante.

string chaine1 = "UN";

string chaine2 = "DEUX";

cout<<"chaine1 : "<<chaine1<<endl;

chaine1.append(chaine2);

cout<<"En exécutant l'instruction chaine1.append(chaine2) ,"<<

"chaine1 devient : "<<chaine1<<endl;

On obtient en sortie : chaine1 : UN

chaine2 : DEUX

En exécutant l'instruction chaine1.append(chaine2) ,chaine1 devient : UNDEUX

Syntaxe:

basic_string &append( const char *str );

Ajoute le contenu de la chaîne "classique" (héritée du langage C) str à la fin de la chaîne courante.

(6)

On obtiendra les mêmes résultats en reprenant l’exemple précédent ,et en prenant soin de changer le type de chaine2 en "const char*"

Syntaxe:

basic_string &append( const basic_string &str, size_type index,size_type len );

Concatène à la fin de la chaîne courante, la sous-chaîne de "str" obtenue à partir de l’indice "index" , et en prenant "len" caractères .

Condition préalable : 0 <= index <= str.size() et len >=0

string chaine1 = "UN DEUX ";

string chaine2 = "TROIS QUATRE";

chaine1.append(chaine2 , 0 , 5);

cout<<"Aprés exécution de chaine1.append((chaine2 , 0 , 5) ,"<<

chaine1.append(chaine2 , 5 , 7);

cout<<"Après chaine1.append((chaine2 , 5 , 7) ,"<<

"chaine devient : "<<chaine1<<endl;

On obtient en sortie : chaine1 : UN DEUX

chaine2 : TROIS QUATRE

Après exécution de chaine1.append((chaine2,0,5) ,chaine1 devient : UN DEUX TROIS

(7)

Après chaine1.append((chaine2,5,7) ,chaine1 devient:UN DEUX TROIS QUATRE.

Syntaxe:

basic_string &append( const char *str, size_type num );

Ajoute"num" caractères de la chaîne "str" à la fin de la chaîne courante . Si "num"

dépasse le nombre de caractères de la chaîne "str" , tous les caractères de celle-ci seront copiés .

Condition préalable : num >=0

string chaine1 = "C ";

const char* chaine2 = "PLUS ";

chaine1.append(chaine2 , 5);

cout<<"Aprés execution de chaine1.append (chaine2 5) ,"<<

chaine1.append(chaine2 , 25);

cout<<"En exécutant chaine1.append(chaine2 , 25) ,"<<

"chaine devient : "<<chaine1<<endl;

On obtient en sortie :

(8)

chaine1 : C chaine2 : PLUS

Après exécution de chaine1.append(chaine2 5) ,chaine1 devient : C PLUS En exécutant chaine1.append(chaine2 , 25) ,chaine devient : C PLUS PLUS

Syntaxe:

basic_string &append( size_type num, char ch );

Ajoute le caractère "ch" , "num" fois à la fin de la chaîne courante .

string message = "Bientôt les vacances ";

cout<<"message : "<<message<<endl;

message.append(8 , '!');

cout<<"Aprés execution de message.append(8 , '!') "<<

"message devient : "<<message<<endl;

message : Bientôt les vacances

Après message.append(8 , '!') message devient : Bientôt les vacances !!!!!!!!

Syntaxe:

basic_string &append( input_iterator debut, input_iterator fin );

Ajoute les caractères délimités par les itérateurs "debut" et "fin" à la fin de la chaîne courante.

string chaine1 = "UN DEUX ";

(9)

string chaine2 = "TROIS QUATRE";

chaine1.append(chaine2.begin() , chaine2.begin()+6);

cout<<"Aprés exécution de chaine1.append(chaine2.begin() , chaine2.begin()+6) ,"<<

chaine1.append(chaine2.begin()+6 , chaine2.end());

cout<<"Aprés exécution de chaine1.append(chaine2.begin()+6 , chaine2.end()) ,"<<

En sortie , on obtient : chaine1 : UN DEUX

chaine2 : TROIS QUATRE

Après exécution de chaine1.append(chaine2.begin() , chaine2.begin()+6) ,chaine1 devient : UN DEUX TROIS

Après exécution de chaine1.append(chaine2.begin()+6 , chaine2.end()) ,chaine1 de vient : UN DEUX TROIS QUATRE.

at

Syntaxe:

reference at( size_type index );

(10)

La fonction at() retourne une référence sur le caractère à l’indice index . Si la valeur de index est négative ou supérieure à la longueur de la chaine moins 1 , la méthode at() lance une une exception (une instance de la classe prédéfinie out_of_range ) pour signaler l’erreur.

string chaine = "ABCDEF";

char ch = chaine.at( 0 );

cout<<ch<<endl; // Affiche A ch = chaine.at( 2 );

cout<<ch<<endl; // Affiche C

begin

Syntax:

iterator begin();

La fonction begin() retourne un itérateur sur le premier caractère de la chaîne courante.

string::iterator it = s.begin();//Retourne un iterateur sur le premier caractere cout<< *it <<endl; // Affiche A

cout<<*(it+2) <<endl; // Affiche C

it++; //On incrémente l’itérateur pour qu’il "pointe" vers le caractère suivant.

cout<< *it <<endl; // Affiche B it--; // On revient à la case de départ.

cout<< *it <<endl; // Affiche à nouveau A

c_str

Syntax:

(11)

const char *c_str();

La fonction c_str() retourne un pointeur sur le premier élément d’un tableau de caractères qui contient tous les caractères de la chaîne courante , en plus du

caractère nul ‘\0’ à la fin de ce tableau (En d’autres termes , une chaîne classique du langage C).

string chaine("ABCDEFG");

const char* chaineClassique = chaine.c_str();

cout<<"Le contenu de la chaîne retournée par c_str() : "<<chaineClassique<<endl;

cout<<"Sa longueur est : "<<strlen(chaineClassique)<<endl;

En sortie,on obtient :

Le contenu de la chaîne retournée par c_str() : ABCDEF Sa longueur est : 7.

clear

Syntaxe:

void clear();

La fonction clear() enlève de la chaîne courante tous les caractères qu’elle contient.

L’appel à la fonction clear est équivalent à l’appel à la fonction erase(begin() , end()).

cout<<"Contenu de la chaine : "<<chaine<<endl;

cout<<"Sa longueur : "<<chaine.length()<<endl;

chaine.clear();

cout<<"Apés l’appel de la fonction clear sur notre chaine :"<<endl;

(12)

cout<<"Son contenu devient : "<<chaine<<endl;

cout<<"Et sa longueur : "<<chaine.length()<<endl;

compare

Syntaxe:

int compare( const basic_string &str );

Compare la chaîne courante avec la chaîne str (du point de vue lexicographique) et retourne un entier :

- positif si la chaîne courante est supérieure à str . - Négatif si la chaîne courante est inférieure à str . - Égal à zéro si la chaîne courante est égale à str .

string str1 = "DEF" ; string st2 = "ABC" ; string str3 = "ABC" ; string str4 = "XYZ" ;

cout<<str1.compare(str2)<<endl; // Affiche 1 cout<<str2.compare(str3)<<endl; //Affiche 0 cout<<str1.compare(str4)<<endl; //Affiche -1

Syntaxe:

int compare( size_type index, size_type length, const basic_string &str );

(13)

Compare la chaîne courante avec str , et ce , à partir de l’indice index en prenant length caractères . Voir la définition précédente de compare pour la valeur de retour.

Condition préalable : length >= 0 , index >=0 et index < size() . string str1 = "ABCDEF" ;

string str2 = "ABC" ;

cout<<str1.compare(0,3 , str2)<<endl; //Affiche 0 cout<<str1.compare(2,4 , str2)<<endl; //Affiche 1

copy

Syntaxe:

size_type copy( char *copie, size_type num, size_type index );

La fonction copy() copie nbCars caractères de la chaîne courante (à partir de l’indice "index" ) dans la chaîne "copie" . La fonction retourne le nombre de caractères effectivement copiés .

Condition préalable : num >= 0 , index >=0 et index < strlen(copie) .

const int MAX_CARS = 26 ; char laCopie[MAX_CARS + 1];

string alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

int nbCars = alphabet.copy(laCopie , MAX_CARS , 0);

laCopie[nbCars ] = '\0'; //La fonction copy() ne fait pas cette tache pour nous!

cout<< "La copie est : "<<laCopie<<endl;

cout<< "Le nombre de caractères copies : "<<nbCars<<endl;

nbCars = alphabet.copy(laCopie , MAX_CARS , 10);

(14)

laCopie[nbCars ] = '\0';

cout<< "La copie est : "<<laCopie<<endl;

cout<< "Le nombre de caractères copiès : "<<nbCars<<endl;

En sortie , on obtient :

La copie est : ABCDEFGHIJKLMNOPQRSTUVWXYZ Le nombre de caractères copies : 26

La copie est : KLMNOPQRSTUVWXYZ Le nombre de caractères copiès : 16

data

Syntaxe:

const char *data();

La fonction data() retourne un pointeur sur le premier caractère de la chaîne courante . Cela permet d’obtenir une "chaîne de caractères classique du langage C"

(Tableau de caractères terminé par le caractère nul ‘\0’) à partir d’un objet

"string".

string str = "Exemple de data()";

const char* chaineClassique = str.data();

cout<< "La chaîne convertie : "<<chaineClassique<<endl;

cout<< "Sa longueur est : "<<strlen(chaineClassique)<<endl;

La chaîne convertie : Exemple de data() Sa longueur est : 17

empty

Syntaxe:

bool empty();

(15)

La fonction empty() retourne true si la chaîne courante est vide , et false sinon.

string chaine1 ; //Le constructeur par défaut construit une chaine vide string chaine2 = "Une chaine qui contient des caractères" ;

cout<<( chaine1.empty()? "chaine1 est vide.":"chaine1 n'est pas vide." )<<endl;

cout<<( chaine2.empty()? "chaine2 est vide.":"chaine2 n'est pas vide." ) <<endl;

En sortie , on obtient : chaine1 est vide.

chaine2 n'est pas vide.

end

Syntax:

iterator end();

La fonction end() retourne un itérateur qui se situe juste après le dernier caractère de la chaîne courante.

string::iterator it = chaine.end();//Retourne un itérateur qui se situe //juste après la fin de la chaîne cout<< *(it-1) <<endl; // Affiche le dernier caractère F

cout<<*(it-chaine.length()) <<endl; // Affiche le premier caractère A it-- ;

cout<< *it <<endl; // Affiche le dernier caractère F

(16)

//On peut combiner les méthodes begin() et end() pour parcourir notre //chaîne à l’aide de l’itérateur it déclaré précédemment .

for(it = chaine.begin(); it != chaine.end(); it++) cout<<*it;

On obtient en sortie : ABCDEF

find

Syntaxe:

size_type find( const basic_string &str, size_type index );

Retourne la position de la chaîne "str" dans la chaîne courante , à partir de la position "index" . Si "str" ne se trouve pas dans la chaine courante , la fonction retourne la position (de type unsigned int) prédéfinie dans la classe string "

string::npos ".

Remarque :

En général , string::npos vaut -1 , mais ceci n’est pas garanti dans tous les environnements de travail . Donc , pour des raisons de portabilité , utilisez string::npos plutôt que la valeur -1 pour tester la valeur retournée par find().

string str1("BONJOUR TOUT LE MONDE!");

const string str2("JOUR");

unsigned int position = str1.find(str2 , 0);

if(position != string ::npos)

cout<< str2<< " se trouve à la position "<<position<< " dans "<< str1<<endl;

else

cout<<"Aucune occurrence de "<<str1<<" dans "<<str2<<endl;

(17)

JOUR se trouve à la position 3 dans BONJOUR TOUT LE MONDE!

size_type find( const char *str, size_type index );

Cette variante de la fonction find() repose sur le même principe que celle définie plus haut .Cette fois , le paramètre est de type "const char *" plutôt que "const basic_string &"

Reprendre l’exemple précédent en changeant le type de str2 comme ceci : const char* str2 = "JOUR";

………..etc

size_type find( const char *str, size_type index, size_type nbCars );

Retourne la position de la sous-chaîne de "str" ("nbCars" premiers caractères) , dans la chaîne courante , à partir de la position "index" . Si cette sous-chaîne ne se trouve pas dans la chaîne courante , la fonction retourne string::npos .

string str1("BONJOUR TOUT LE MONDE!");

const char* str2 = "JOURNEE" ;

unsigned int position = str1.find(str2 , 0 ,4);

cout<< string(str2).substr(0,4)<< " se trouve à la position "<<position<<

<<" dans "<<str1<<endl;

else

cout<<"Aucune occurrence de "<<string(str2).substr(0,4)<<" dans "<<str1<<endl;

(18)

position = str1.find(str2 , 0 ,7);

cout<< string(str2).substr(0,7)<< " se trouve à la position "<<position<< " dans "<<

<<str1<<endl;

else

cout<<"Aucune occurrence de "<<string(str2).substr(0,7)<<" dans "<<str1<<endl;

En sortie,on obtient :

JOUR se trouve à la position 3 dans BONJOUR TOUT LE MONDE!

Aucune occurrence de JOURNEE dans BONJOUR TOUT LE MONDE!

size_type find( char ch, size_type index );

Retourne la position du caractère "ch" dans la chaîne courante , à partir de l’indice

"index". Si aucune occurrence n’est trouvée , string::npos est retournée.

string chaine("ABCDEF");

unsigned int position = chaine.find(‘C’,0);

cout<<"À partir du début de "<<chaine<<"On trouve le caractère C à la position "<<

position<<endl;

else

cout<<"À partir du début de "<<chaine<<"aucune occurrence du caractere C n’est "<<

(19)

"rencontrée." <<endl;

position = chaine.find(‘C’,3);

cout<<"À partir du quatrième caractère de "<<chaine<<"On trouve le caractère C à " <<

"la position "<<position<<endl;

else

cout<<"À partir du quatrième caractère de "<<chaine<<" aucune occurrence du "<<

"caractère C n’est rencontrée." <<endl;

À partir du début de ABCDEF on trouve le caractère C à la position 2

À partir du quatrième caractère de ABCDEF aucune occurrence du caractère C n'est rencontrée.

length

Syntaxe:

(20)

size_type length();

La fonction length() retourne le nombre de caractères de la chaîne courante (Même résultat obtenu avec size()).

string chaine ("ABCD");

cout<<chaine.length()<<endl; // Affiche 4

size

Syntaxe:

size_type size();

La fonction size() retourne le nombre de caractères dans la chaîne courante.

string chaine ("ABCD");

cout<<chaine.size()<<endl; // Affiche 4

substr

Syntaxe:

basic_string substr( size_type index, size_type num = npos );

La fonction substr() retourne la sous-chaîne de la chaîne courante , et ce , en prenant "num" caractères à partir de l’indice "index".

Si le deuxième paramètre n’est pas spécifié , le paramètre string ::nbpos est passé par défaut , et la méthode retourne le reste de la chaîne à partir de l’indice "index".

string chaine = "UN DEUX TROIX QUATRE";

//À partir de l’indice 0 , on prend 7 caractères.

string sousChaine = chaine.substr(0,7);

cout<<sousChaine<<endl;//Affiche UN DEUX

//À partir de l’indice 8 , on prend le reste de la chaîne.

(21)

sousChaine = chaine.substr(8);

cout<<sousChaine<<endl;//Affiche TROIS QUATRE

//À partir de l’indice 8 , on prend 99 caractères.Malheureusement , il //ne reste pas assez de caractères pour satisfaire la demande . On //se contente alors du reste de la chaîne courante.

sousChaine = chaine.substr(8,99);

cout<<sousChaine<<endl;//Affiche TROIS QUATRE

swap

Syntaxe:

void swap( basic_string &str );

La fonction swap() échange la chaîne str avec la chaîne courante.

string premiere( "La première chaîne." );

string deuxieme( "La deuxième chaîne" );

premiere.swap(deuxieme);

cout << premiere << endl;

cout << deuxieme << endl;

On obtient en sortie : La première chaîne.

La deuxième chaîne.