STL : La librairie Algorithm - David Saint

Transcription

Langage C++
STL - Les fonctions algorithmes
05/02/03
1
INTRODUCTION .......................................................................................................................................................... 1
1.1
1.2
1.3
1.4
2
OPÉRATIONS GÉNÉRALES DE MANIPULATION DES DONNÉES ......................................................................................... 3
2.1
2.2
2.3
3
Tester l’égalité de contenu : equal() ................................................................................................................................... 14
Rechercher les objets dichotomiques (différents) : mismatch()............................................................................................ 14
Tester l’infériorité - Comparaison lexicographique : lexicographical_compare().................................................................. 14
LES OPÉRATIONS ENSEMBLISTES SUR 2 SÉQUENCES ................................................................................................... 15
7.1
7.2
7.3
7.4
7.5
7.6
7.7
8
Trier tous les objets : sort(), stable_sort(), partial_sort()...................................................................................................... 12
Trier partiellement les objets : partial_sort() ....................................................................................................................... 12
Inverser l’ordre des objets : reverse() ................................................................................................................................. 13
Mélanger les objets : random_shuffle() .............................................................................................................................. 13
OPÉRATIONS DE COMPARAISON DE 2 SÉQUENCES ...................................................................................................... 14
6.1
6.2
6.3
7
Position du plus Petit et du plus Grand : min_element(), max_element() ............................................................................... 9
Rechercher la 1ère occurrence : find(), find_if(), find_first_of(), search(), find_end(),search_n().......................................... 9
Position du 1er doublons : adjacent_find() ........................................................................................................................... 10
Position pour insérer une valeur dans une séquence triée : lower_bound(), upper_bound(), equal_range() ............................ 11
OPÉRATIONS D'ORDONNANCEMENT .......................................................................................................................... 12
5.1
5.2
5.3
5.4
6
Supprimer des objets : remove(), remove_if() et unique() .................................................................................................... 5
Remplacer des objets : replace(), replace_if() ....................................................................................................................... 6
Appliquer un traitement à des objets : transform() et for_each() ............................................................................................ 7
Rechercher si une valeur est présente: binary_search().......................................................................................................... 8
Compter des objets : count () et count_if ()........................................................................................................................... 8
OPÉRATIONS DE RECHERCHE DE LA POSITION D’UN OBJET PARTICULIER ....................................................................... 9
4.1
4.2
4.3
4.4
5
Copier : copy() et copy_backward() .................................................................................................................................... 3
Initialiser et remplir fill(), fill_n(), generate(), generate_n()................................................................................................... 3
Echanger les objets de 2 séquences : swap_ranges() ............................................................................................................. 4
OPÉRATIONS SUR UNE SÉQUENCE AVEC UN CRITÈRE .................................................................................................... 5
3.1
3.2
3.3
3.4
3.5
4
Les fonctions....................................................................................................................................................................... 2
La séquence d’un conteneur................................................................................................................................................. 2
Cas du tableau..................................................................................................................................................................... 2
Notations adoptées .............................................................................................................................................................. 2
Vérifier l’inclusion d’une séquence dans une autre ............................................................................................................. 15
Effectuer l’intersection de 2 séquences : set_intersection().................................................................................................. 15
Fusionner 2 séquences : merge() ........................................................................................................................................ 15
Faire l’union de 2 séquences : set_union () ......................................................................................................................... 16
Fusionner au sein d’une séquence : inplace_merge()........................................................................................................... 16
Etablir la différence de 2 séquences : set_difference(), set_ symmetric_difference() ............................................................ 16
Partitionner une séquence selon un critère : partition(), stable_partition() ............................................................................ 18
TABLE DES EXEMPLES DE CODE ................................................................................................................................ 18
1 INTRODUCTION
Le terme séquence est utilisé ici pour indiquer une suite d’objets.
La majorité des fonctions sont présentées, il manque : make_heap(), max(), min(), next_permutation(),
nth_element(), pop_heap(), prev_permutation (), push_heap(), rotate(), rotate_copy(), sort_heap(), swap().
Le conteneur vector est souvent utilisé dans les exemples.
David Saint-Mellion
page 1/18
Langage C++
05/02/03
1.1 Les fonctions
La librairie standard «STL» définit un jeu de fonctions « Templates » traitant les algorithmes les plus connus.
Elles sont définies dans l'en-tête <algorithm>. Elles réalisent toutes les opérations classiques comme : la
création, la copie, la suppression, le remplacement, l’ordonnancement (tri). Elles s’appliquent à une séquence
d’objets d’un conteneur. Elles peuvent opérer sur 2 conteneurs de nature différents à condition qu’ils
contiennent des objets de même type, Exemples : Copier la séquence d’un tableau d’entiers dans une liste
d’entiers ou bien, comparer une séquence d’une liste de flottants avec une séquence de flottants d’un vector.
De manière générale ces fonctions :
• Reçoivent en paramètres les 2 itérateurs définissant une
ItrPrem
itrDer
séquence dans un conteneur source.
• Parcourent la séquence pour effectuer le
1 2 3 4 5 6 7 8 9
traitement.
Exemple : Afficher un tableau de 10 entiers à l’écran :
int source[10]={1,2,3,4,5,6,7,8,9,10};
ostream_iterator<int> ecran(cout," "); // Définition d’un itérateur adaptateur
copy(source,source+10,ecran);
Les conteneurs disposent de fonctions membres issues de <algorithm> adaptées à son type. Il faut privilégier
l’emploi de ses fonctions. En général, elles opèrent sur l’ensemble des objets du conteneur alors que les
fonctions de <algorithm> peuvent opérer sur seulement une partie des données d’un conteneur.
1.2 La séquence d’un conteneur
Un conteneur (vector, liste, ..., un tableau) contient une série d’objets de même type et qui se suivent. La
séquence est définie par 2 itérateurs. L’intervalle ainsi défini constitue un espace ouvert : le dernier objet pointé
par itrDer n’appartient pas à l’intervalle, ici itrDer =itrPrem+10. Une séquence peut être constituée par tous les
objets d’un conteneur ou une seulement une partie. Pour accéder à un objet de la séquence, il suffit de
déplacer l’itérateur : Exemple pour accéder à l’objet 3, itrAcces3=irtDébut+2.
Les conteneurs de la STL disposent de 2 fonctions renvoyant les itérateurs Début et Fin du conteneur : Début
du conteneur - begin() et Fin du conteneur - end().
Pour l’exemple de la séquence ci-dessus contenue complètement d’un conteneur «monVector», l’accéder à
l’objet 3 se réalise par : itrAcces3=monVector. begin()+3 ou itrAcces3=monVector.end()-7.
1.3 Cas du tableau
C’est le conteneur «rustique» hérité du langage C. Le pointeur sur un objet du tableau est vu comme un
itérateur. Les fonctions de l'en-tête <algorithm> peuvent s’appliquer aux tableaux.
1.4 Notations adoptées
Les itérateurs
Notation
ItrInput
ItrOutput
ItrForward
ItrBidirectional
ItrRandomAccess
Type d’itérateur
input_iterator
outpout_iterator
forward_iterator
bidirectional_iterator
random_acces_iterator
Types de fontceurs ou fonctions
generator
Fonction avec aucun paramètre, retourne la valeur d’un objet
predicate
Foncteur avec 2 paramètres et retourne un booléen
predicateBinaire
Foncteur avec 2 paramètres et retourne un booléen
operationUnaire
Foncteur avec 1 paramètre et retourne une valeur
operationBinaire
Foncteur avec 2 paramètres et retourne une valeur
function
Foncteur adaptateur
compare
Fonction compare au sens de l’infériorité
David Saint-Mellion
page 2/18
Langage C++
05/02/03
2 OPÉRATIONS GÉNÉRALES DE MANIPULATION DES DONNÉES
2.1 Copier : copy() et copy_backward()
La fonction copy() : copie une séquence ailleurs (3ème argument). La fonction backward_copy copie une
séquence ailleurs en partant de la fin. La séquence copiée peut être affectée soit au même conteneur, soit à un
autre conteneur.
• itrOutput copy(itrInput prem, itrInput der, itrOutput destination);
• itrBidirectional copy_backward(itrBidirectional prem, itrBidirectional der,
itrBidirectional fin_destination);
Exemple 1 : Copier et afficher
#include <iostream>
#include <vector>
#include <algorithm> // pour copy
using namespace std;
int main(void){
int source[10]={1,2,3,4,5,6,7,8,9,10};
// Définit un vector de 10 entiers
vector<int> destination(10);
// Copie les objets de itérateur Début "source" à itérateur Fin
// "source+4"(non compris), dans destinationDebut "destination.begin()"
copy(source,source+4,destination.begin());
// Copie inverse les objets référencés de itérateur Début
// à itérateur Fin (objet non compris) à partir de destinationFin
copy_backward(source+4,source+8,destination.end());
// Définit un itérateur adaptateur sur la sortie standard
ostream_iterator<int> ecran(cout," ");
// Affiche à l'écran avec la fonction copy
copy(source,source+10,ecran);
cout<<endl;
copy(destination.begin(),destination.end(),ecran);
cout<<endl;
return 0;
}
Résultat de l’exécution
1 2 3 4 5 6 7 8 9 10
1 2 3 4 0 0 5 6 7 8
Remarques :
• La fonction membre des conteneurs, assign(), copie seulement à partir du début du conteneur dans
destination.
• Dans l’exemple, l’utilisation d’un itérateur adaptateur permet de disposer d’un itérateur sur un flux de
données en sortie et de traiter l’affichage à l’écran grâce à la fonction copy(). Il en est de même pour les flux
d’entrée. Ce principe s’applique aussi au flux fichier. Exemple :
// Définit un vector de flottants
vector<float> vecCote;
// Lit le fichier et insère les valeurs dans le vector
copy(istream_iterator<float>(fichierCote), istream_iterator<float>(),
back_inserter(vecCote) // Insère l’objet à la fin du vector
);
// Définit un itérateur adaptateur pour écrire dans le fichier.
// Le séparateur des données est \n
ostream_iterator<float> itrFichier (fichierCote,"\n");
// Ecrit dans le flux fichiers
copy(vecCote.begin(),vecCote.end(),itrFichier);
2.2 Initialiser et remplir fill(), fill_n(), generate(), generate_n()
Ces fonctions initialisent un conteneur avec une valeur ou génèrent une série de valeurs pour l’initialiser.
La fonction fill() affecte une valeur (3ème argument) à chaque objet d’une séquence.
David Saint-Mellion
page 3/18
Langage C++
05/02/03
La fonction generate() remplit une séquence à partir des valeurs générées par une fonction (3ème argument), à
chaque appel elle produit une valeur. Elle ne prend aucun paramètre et renvoie la nouvelle valeur.
Les fonctions sont disponibles sous 2 versions. Pour la 1ère version, l’intervalle de la séquence est repéré par
les 2 premiers itérateurs, pour la 2ème version, la séquence est définie par un itérateur sur le premier objet et le
nombre d’objets.
• void fill(itrForward prem, itrForward der, const T &valeur);
• void fill_n(itrOutput prem, Size nombre, const T &valeur);
• void generate(itrForward prem, itrForward der, generator g);
• void generate_n(itrOutput prem, Size nombre, generator g);
2.3 Echanger les objets de 2 séquences : swap_ranges()
La fonction swap_ranges() intervertit les objets entre 2 séquences.
• itrForward swap_ranges(itrForward prem, itrForward der, itrForward
destination);
Exemple 2 : Initialiser et échanger des objets
#include <iostream>
#include <deque>
#include <vector>
#include <algorithm>
#include <iterator>
// pour ostream_iterator
int serieA2(){
// Génère une série arithmétique
static int a=0;
return (a=a+2);
}
int serieG2(){
// Génère une série géométrique
static int g=1;
return (g=g*2);
}
int main(void){
int tab[10];
deque<int> maDeq;
vector<int> monVecteur;
// Remplit le tableau avec 255
fill(tab,tab+10,255);
// Remplit un vecteur de 10 objets avec la série arithmétique
generate_n(back_inserter(monVecteur),10,serieG2);
// Remplit une deque de 10 objets avec la série géométrique
generate_n(back_inserter(maDeq),10,serieA2);
// Affiche les valeurs des 3 conteneurs
copy(tab, tab+10,ecran);
cout<<endl;
copy(monVecteur.begin(),monVecteur.end(),ecran);
cout<<endl;
copy(maDeq.begin(),maDeq.end(),ecran);
cout<<endl<<endl<<"Echange entre le tableau et momVecteur"<<endl;
// Echange entre le tableau et momVecteur
swap_ranges(tab, tab+4, monVecteur.begin());
copy(tab, tab+10,ecran);
cout<<endl;
copy(monVecteur.begin(),monVecteur.end(),ecran);
cout<<endl<<endl<<"Echange dans la deque "<<endl;
// Echange dans la queue
swap_ranges(maDeq.begin(), maDeq.begin()+4, maDeq.begin()+6);
copy(maDeq.begin(),maDeq.end(),ecran);
cout<<endl;
David Saint-Mellion
page 4/18
Langage C++
05/02/03
return 0;
}
255 255 255 255 255 255 255 255 255 255
2 4 8 16 32 64 128 256 512 1024
2 4 6 8 10 12 14 16 18 20
Echange entre le tableau et momVecteur
2 4 8 16 255 255 255 255 255 255
255 255 255 255 32 64 128 256 512 1024
Echange dans la deque
14 16 18 20 10 12 2 4 6 8
3 OPÉRATIONS SUR UNE SÉQUENCE AVEC UN CRITÈRE
Les fonctions effectuent un traitement systématique à tous les objets ou opérer seulement sur ceux qui ont une
valeur particulière ou répondant à un critère afin de les supprimer, remplacer, compter.
Les versions utilisant une fonction prédicat, exemple remove_if () opèrent sur les objets de la séquence lorsque
la fonction prédicat retourne false. L’itérateur retourné repère l'objet après le dernier objet de la séquence
résultat. Les versions qui ont pour suffixe _copy placent le résultat dans une séquence sans modifier la
séquence d’origine.
3.1 Supprimer des objets : remove(), remove_if() et unique()
Ces fonctions sont utilisées pour effectuer un filtre dont le but est de supprimer des objets selon un critère.
La fonction remove() supprime les objets de la séquence ayant une valeur particulière et remove_copy duplique
ces objets dans une autre séquence.
• itrForward remove(itrForward prem, itrForward second, const T &valeur);
• itrOutput remove_copy(itrInput prem, itrInput second, itrOutput destination,
const T &valeur);
La fonction remove_if () supprime tous les objets d’une séquence ne répondant pas à une condition et
remove_if () duplique ces objets dans une autre séquence.
• itrForward remove_if(itrForward prem, itrForward second, predicate p);
• itrOutput remove_copy_if(itrInput prem, itrInput second, itrOutput destination,
predicate p);
Les fonctions - unique() - suppriment les doublons : 2 valeurs qui se suivent dans la séquence.
• itrForward unique(itrForward prem, itrForward der);
• itrOutput unique_copy(itrForward prem, itrForward der);
• itrForward unique(itrForward prem, itrForward der, predicateBinaire p);
• itrOutput unique_copy(itrForward prem, itrForward der, predicateBinaire p);
Exemple 3 : Supprimer des objets
#include <iostream>
#include <vector>
#include <list>
#include <functional> // pour ptr_fun
bool plusGrandt(int val){
return (val<50);
}
int soureceData[10]={20,11,52,11,54,55,11,52,11,23};
int main(void){
vector<int> data(soureceData,soureceData+10);
list<int> destination(10);
// Définit les itérateurs
vector<int>::iterator itrDerVtr=NULL; // Définit un itr de vector d'entiers
list<int>::iterator itrDerLte=NULL; // Définit un itr d'une liste d'entiers
David Saint-Mellion
page 5/18
Langage C++
05/02/03
ostream_iterator<int> ecran(cout," "); // Définit un itr sortie standard
// Supprime les objets valant 11 et récupère la valeur de l'itérateur fin
itrDerVtr=remove(data.begin(),data.end(),11);
copy(data.begin(),itrDerVtr,ecran);
cout<<endl;
// Crée une copie des objets supérieurs à 49
// Récupère la valeur de l'itérateur de fin
itrDerLte=remove_copy_if(data.begin(),data.end(),
destination.begin(),ptr_fun(&plusGrandt));
copy(data.begin(),itrDerVtr,ecran);
cout<<endl;
copy(destination.begin(),itrDerLte,ecran);
cout<<endl;
// Supprime les doublons, 2 valeurs qui se suivent
// Récupère la valeur de l'itérateur de fin
itrDerLte=unique(destination.begin(),itrDerLte);
copy(destination.begin(),itrDerLte,ecran);
cout<<endl;
return 0;
}
20 52 54 55 52 23
20 52 54 55 52 23
52 54 55 52 52
52 54 55 52
Remarque :
Ces fonctions ne modifient la séquence à partir de l’itérateur renvoyé.
Exemple : remove(data.begin(),data.end(),11
• Séquence avant exécution :
20,11,52,11,54,55,11,52,11,23
• Séquence après l’exécution :
20 52 54 55 52 23 11 52 11 23
Ce n’est pas le cas des fonctions erase() des conteneurs ou remove() du conteneur list qui procèdent par
écrasement des valeurs à supprimer en copiant la séquence qui suit.
3.2 Remplacer des objets : replace(), replace_if()
La fonction replace() remplace tous les objets ayant une valeur particulière par une nouvelle valeur et
replace_copy() crée une copie des objets modifiés ailleurs.
• void replace(itrForward prem, itrForward der, const T ancienne_valeur, const T
&nouvelleVal);
• void replace_if(itrForward prem, itrForward der, predicate p,
const T &nouvelleVal);
La fonction replace_copy () supprime les objets de la séquence ne répondant pas à une condition et
replace_copy_if() duplique ces objets dans une autre séquence. La condition est définie par une fonction
prédicat.
•
void replace_copy(itrInput prem, itrInput der, itrOutput destination, const T
&ancienne_valeur, const T &nouvelleVal);
• void replace_copy_if(itrInput prem, itrInput der, itrOutput destination,
predicate p, const T &nouvelleVal);
Exemple 4 : Rechercher et remplacer des objets
#include <iostream>
#include <list>
#include <vector>
#include <functional>
// pour ptr_fun
bool plusPetit(int val){
return (val<10);
David Saint-Mellion
page 6/18
Langage C++
05/02/03
}
int sourceData[10]={1,1,50,1,4,10,6,7,1,9}; // Data source
int main(void){
vector<int> vec(sourceData, sourceData+10);
list<int> data(10);
// Remplace tous les objets valant 1 par des 88
replace(vec.begin(),vec.end(),1,88);
copy(vec.begin(),vec.end(),ecran);
cout<<endl;
// Remplace tous les objets < à 10 par 0
replace_copy_if(vec.begin(),vec.end(),data.begin(),ptr_fun(&plusPetit),0);
copy(data.begin(),data.end(),ecran);
cout<<endl;
return 0;
}
88 26 56 88 4 18 6 4 88 4
88 26 56 88 0 18 0 0 88 0
3.3 Appliquer un traitement à des objets : transform() et for_each()
La fonction for_each() effectue une opération de lecture des objets de la séquence. Elle transmet chaque objet à
une fonction.
• function for_each(itrInput prem, itrInput der, function f);
La fonction transform() modifie les objets d'une séquence en leur appliquant une fonction de traitement. La
première version applique une fonction unaire sur l’objet «prem», place le résultat dans «destination» et itère.
L’autre version applique une fonction binaire sur deux objets «prem1», «prem2», place le résultat dans
«destination» et itère sur les 2 éléments.
• itrOutput transform(itrInput prem, itrInput der, itrOutput destination,
operationUnaire op);
• itrOutput transform(itrInput prem1, itrInput der1, itrInput prem2, itrOutput
destination, operationBinaire op);
Exemple 5 : Parcourir et traiter les objets d’une séquence
#include <iostream>
#include <vector>
#include <deque>
// pour negate<int>() et ptr_fun
int afficher(int val){
// Affiche val
cout<<val<<' ';
return 0;
}
int ajouter(int val){
// Ajoute 10
return (val+10);
}
int calculer(int val1, int val2){ // Fait le calcul
static n=0;
return (val1+val2+n++);
}
// Data source
int sourceData[10]={0,-1,-2,3,4,5,6,7,8,9};
int main(void){
// Définit un vector et l'initialise
vector<int> source(sourceData,sourceData+10);
// Définit une deque de 10 entiers
David Saint-Mellion
page 7/18
Langage C++
05/02/03
deque<int> dest(10);
// Parcourt le vector et inverse la valeur de l'objet
// La fonction negate() est une fonction instanciée pour un entier
// dest[n] <-- -source[n]
transform(source.begin(),source.end(),dest.begin(),negate<int>());
// Affiche le résultat
for_each(dest.begin(),dest.end(),ptr_fun(&afficher));
cout<<endl;
// source[n] <-- source[n]+10 à chaque objet
transform(source.begin(),source.end(),source.begin(),ptr_fun(&ajouter));
// Affiche le résultat
for_each(source.begin(),source.end(),ptr_fun(&afficher));
cout<<endl;
// dest[n]<-- dest[n]+source[n]+1
transform(source.begin(),source.end(),
dest.begin(),dest.begin(),ptr_fun(&calculer));
for_each(dest.begin(),dest.end(),ptr_fun(&afficher));
cout<<endl;
return 0;
}
0 1 2 -3 -4 -5 -6 -7 -8 -9
10 9 8 13 14 15 16 17 18 19
10 11 12 13 14 15 16 17 18 19
3.4 Rechercher si une valeur est présente: binary_search()
La fonction binary_search() indique si une valeur est présente dans une séquence triée. Elle renvoie un bool détermine
si un objet est au moins est équivalent à une valeur donnée ou au sens d'une fonction fourni en paramètre.
• bool binary_search(itrForward prem, itrForward der, const T &valeur);
• bool binary_search(itrForward prem, itrForward const T &valeur, compare c);
3.5 Compter des objets : count () et count_if ()
La fonction count()compte le nombre d’occurrences d’une valeur.
• count(itrInput prem, itrInput der, const T &valeur);
La fonction count_if()compte le nombre d’objets répondant à une condition.
• count_if(itrInput prem, itrInput der, predicate p);
Exemple 6 : Compter des objets d’une séquence
#include <iostream>
// pour ptr_fun
#include <deque>
bool valPair(int val){
return (val&1)==0;
}
// Teste si la valeur est paire
int sourceData[10] = {1,81,7,32,14,53,16,7,68,91}; // Data source
int main(void){
deque<int> source(10); // Définit une deque de 10 entiers
int nbrePair=0;
int nbreSept=0;
copy(sourceData, sourceData+10,source.begin());
// Compte le nombre d'objets pairs
nbrePair=count_if(source.begin(),source.end(),ptr_fun(&valPair));
// Compte le nombre d'objets supérieurs à 7
nbreSept=count(source.begin(),source.end(), 7);
cout<< nbrePair<<" Elements sont pairs"<< endl;
David Saint-Mellion
page 8/18
Langage C++
05/02/03
cout<< nbreSept<<" Elements valent 7"<< endl;
return 0;
}
4 Elements sont pairs
2 Elements valent 7
4 OPÉRATIONS DE RECHERCHE DE LA POSITION D’UN OBJET PARTICULIER
4.1 Position du plus Petit et du plus Grand : min_element(), max_element()
Deux fonctions permettent d'obtenir la position du plus petit et le plus grand des objets d'une séquence. Elles
retournent un itérateur référençant l’objet le plus petit ou le plus grand.
• itrForward min_element(itrForward prem, itrForward der);
• itrForward min_element(itrForward prem, itrForward der, compare c);
• itrForward max_element(itrForward prem, itrForward der);
• itrForward max_element(itrForward prem, itrForward der, compare c);
Exemple 7 : Rechercher la position du Maxi et du Mini
#include <iostream>
#include <vector>
// Data Source
int sourceDat[10]={2,-3,17,5,4,11,8,1,19,6};
int main(void){
// Définit un vector et l'initialise
vector<int> data(sourceDat,sourceDat+10);
// Définit 2 variables itérateur vector d'entiers
vector<int>::iterator min;
vector<int>::iterator max;
// Recherche la position du min et du max
min=min_element(data.begin(), data.end());
max=max_element(data.begin(), data.end());
// Affiche la position et la valeur du min et du max
cout<<"Le plus Petit est en "<<min-data.begin()<<" et vaut "<<min[0]<<endl;
cout<<"Le plus Grand est en "<<max-data.begin()<<" et vaut "<<max[0]<<endl;
return 0;
}
Le plus Petit est en 1 et vaut -3
Le plus Grand est en 8 et vaut 19
4.2 Rechercher la 1ère occurrence : find(), find_if(), find_first_of(), search(),
find_end(),search_n()
Ces fonctions recherchent la position d’un objet répondant à un critère : une valeur, un motif ou défini par une
fonction.
ème
Les fonctions find() et find-if() renvoie un itérateur sur le premier objet correspondant (3
argument) à une
valeur ou à critère défini par une fonction prédicat unaire.
• itrInput find(itrInput prem, itrInput der, const T &valeur);
• itrInput find_if(itrInput prem, itrInput der, predicate p);
La fonction find_first_of() renvoie un itérateur sur le premier objet qui est égal à une des valeurs d'une autre
séquence. Elle prend deux couples d'itérateurs en paramètre. Le premier définit la séquence sur lequel
s’applique la recherche. Le deuxième définit la séquence spécifiant les valeurs servant à la recherche. Une
deuxième version de la fonction effectue la recherche avec une fonction prédicat binaire. Elle reçoit pendant
l’exécution en paramètre l'objet courant et une des valeurs de la séquence «prem2» et «dern2»
David Saint-Mellion
page 9/18
Langage C++
05/02/03
•
itrInput find_first_of(itrInput prem1, itrInput der1, itrForward prem2,
itrForward der2);
• itrInput find_first_of(itrInput prem1, itrInput der1, itrForward prem2,
itrForward der2, predicateBinaire p);
Un motif est suite de valeurs. La fonction search() renvoie l’itérateur sur la première occurrence d'un motif.
La fonction find_end() renvoie l’itérateur sur la dernière occurrence d'un motif.
• itrForward search(itrForward prem1, itrForward der1, itrForward prem2,
itrForward der2);
• itrForward search(itrForward prem1, itrForward der1, itrForward prem2,
• itrForward find_end(itrForward prem1, itrForward der1, itrForward prem2,
itrForward der2);
• itrForward find_end(itrForward prem1, itrForward der1, itrForward prem2,
La fonction search_n() recherche une série de valeurs identiques. Elle renvoie la position de la première
occurrence de la série de valeurs.
• itrForward search_n(itrForward prem, itrForward der, Size nombre, const T
&valeur);
• itrForward search_n(itrForward prem, itrForward der, Size nombre, const T
&valeur, predicateBinaire p);
4.3 Position du 1er doublon : adjacent_find()
La fonction adjacent_find() renvoie l'itérateur sur le premier doublon. Si aucun objet ne répond au critère de
recherche l’itérateur retourné est itrDernier. Il est inutile de préciser valeur. Un doublon est constitué par deux
valeurs qui se suivent.
• itrForward adjacent_find(itrForward prem, itrForward der);
La version avec un prédicat binaire définit la relation de comparaison utilisée.
• itrForward adjacent_find(itrForward prem, itrForward der, predicateBinaire p);
Exemple 8 : Rechercher de positions - Occurrence et doublon
#include <iostream>
// pour ptr_fun
#include <vector>
bool impair(int val){
// Teste si la valeur est impaire
return ((val&1)!=0);
}
// Data source
int sourceData[10] ={12,12,21,30,4,4,4,21,30,4};
int motifData[3] ={21,30,4};
int main(void) {
// Définit et Initialise 2 vectors d'entiers
vector<int> source(sourceData,sourceData+10);
vector<int> motif(motifData,motifData+3);
// Définit des itérators de vectors d'entiers
vector<int>::iterator itrDebut =source.begin();
// Début source
vector<int>::iterator itrDernier =source.end();
// Dernier source
vector<int>::iterator itrTrouve=NULL;
// Variable
vector<int>::iterator itrTrouveDer;
// Variable
vector<int>::iterator itrIndex;
// Variable d'index
// Recherche la première nombre impair
itrTrouve=find_if(itrDebut,itrDernier,ptr_fun(&impair));
cout<<"Premiere occurrence d'un nombre impair en "
<<itrTrouve-itrDebut<<endl;
David Saint-Mellion
page 10/18
Langage C++
05/02/03
// Recherche la première occurrence du motif 4 4 4
itrTrouve=search_n(itrDebut,itrDernier,3,4);
cout<<"Premiere occurrence 4-4-4 est en "<<itrTrouve-itrDebut<<endl;
// Recherche la position de tous les doublons
itrIndex=itrDebut;
// Initialise la variable d'index
while ((itrTrouve=adjacent_find(itrIndex,itrDernier))!=itrDernier) {
cout<<"Doublon en "<<itrTrouve-itrDebut;
cout<<" Valeurs "<<itrTrouve[0]<<"-"<<itrTrouve[1]<<endl;
// Déplace Début pour continuer l'analyse de la séquence
itrIndex=itrTrouve+1;
}
// Recherche la première occurrence du motif 3 21 30
itrTrouve=search(itrDebut,itrDernier,motif.begin(),motif.end());
// Recherche la dernière occurrence du motif 3 21 30
itrTrouveDer=find_end(itrDebut,itrDernier,motif.begin(),motif.end());
// Traite l'affichage des occurrences du motif
if (itrTrouve==itrDernier)
cout<<"Il n'y a pas occurrence 3 21 30" <<endl;
else if(itrTrouve==itrTrouveDer){
cout<<"Il y a une seule occurrence du motif en ";
cout<<itrTrouve-itrDebut<<endl;
}
else {
cout<<endl<<"Il y a plusieurs occurrences du motif 3 21 30"
<<endl;
cout<<" - La 1ere occurrence est en ";
cout<<itrTrouve-itrDebut<<endl;
cout<<" - Derniere occurrence est en ";
cout<<itrTrouveDer-itrDebut<<endl;
}
return 0;
}
Premiere occurrence d'un nombre impair en 2
Premiere occurrence 4-4-4 est en 4
Doublon en 0 Valeurs 12-12
Il y a plusieurs occurrences du motif 3 21 30
- La 1ere occurrence est en 2
- Derniere occurrence est en 7
4.4 Position pour insérer une valeur dans une séquence triée : lower_bound(),
upper_bound(), equal_range()
La fonction lower_bound() renvoie la première position pour insérer une valeur d’une séquence triée sans
modifier l’ordre.
• itrForward lower_bound(itrForward prem, itrForward der, const T &valeur);
• itrForward lower_bound(itrForward prem, itrForward der, const T &valeur,
compare c);
La fonction l'algorithme upper_bound() renvoie la dernière position pour insérer une valeur d’une séquence triée
sans modifier l’ordre. Un motif est une séquence d’objets caractérisée par leur valeur.
•
•
itrForward upper_bound(itrForward prem, itrForward der, const T &valeur);
itrForward upper_bound(itrForward prem, itrForward der, const T &valeur,
compare c);
La fonction equal_range() renvoie une paire d'itérateurs de la première et la dernière de position pour insérer
une valeur d’une séquence triée sans modifier l’ordre.
David Saint-Mellion
page 11/18
Langage C++
•
•
05/02/03
equal_range(itrForward prem, itrForward der, const T &valeur);
equal_range(itrForward prem, itrForward der, const T &valeur, compare comp);
Exemple 9 : Insérer une valeur dans une séquence triée
#include <iostream>
// pour ptr_fun
int afficher(int val){
// Affiche val
cout<<val<<" ";
return 0;
}
int main(void){
int source[10]={ 2,5,6,7,7,9,11,11,11,17};
int val=7;
pair<int *,int *> intervalle; //Définit une variable paire
for_each(source,source+10,ptr_fun(&afficher));
cout << endl;
// Positions possibles d'insertion de 7
intervalle.first=lower_bound(source,source+10,val);
intervalle.second=upper_bound(source,source+10,val);
cout<<val<<" insertion ["<<intervalle.first-source<<" "
<<intervalle.second-source<<"]"<<endl;
// Positions possibles d'insertion de 11
intervalle=equal_range(source,source+10,11);
cout<<"11"<<" insertion ["<<intervalle.first-source<<" "
<<intervalle.second-source<<"]"<<endl;
return 0;
}
2 5 6 7 7 9 11 11 11 17
7 insertion [3 5]
11 insertion [6 9]
5 OPÉRATIONS D'ORDONNANCEMENT
5.1 Trier tous les objets : sort(), stable_sort(), partial_sort()
Les opérations de tri s'appuient la manipulation des tas. La fonction sort() trie une séquence dans l'ordre
croissant. La fonction stable_sort() trie dans l'ordre croissant, par contre les objets égaux sont maintenus dans
l'ordre initial. Il est possible d'utiliser un autre critère, en spécifiant une fonction binaire en troisième paramètre.
• void sort(itrRandomAccess prem, itrRandomAccess der);
• void sort(itrRandomAccess prem, itrRandomAccess der, compare c);
• void stable_sort(itrRandomAccess prem, itrRandomAccess der);
• void stable_sort(itrRandomAccess prem, itrRandomAccess compare c);
5.2 Trier partiellement les objets : partial_sort()
La fonction partial_sort() trie partiellement d'une séquence. La fonction partial_sort_copy() copie le résultat du tri
partiel dans une autre séquence.
• void partial_sort(itrRandomAccess prem, itrRandomAccess pivot, itrRandomAccess
der);
• itrRandomAccess partial_sort_copy(itrInput prem,itrInput der, itrRandomAccess
debut_resultat, itrRandomAccess fin_resultat);
• void partial_sort(itrRandomAccess prem, itrRandomAccess fin_tri,
itrRandomAccess der, compare c);
• itrRandomAccess partial_sort_copy(itrInput prem, itrInput der, itrRandomAccess
debut_resultat, itrRandomAccess fin_resultat, compare c);
David Saint-Mellion
page 12/18
Langage C++
05/02/03
5.3 Inverser l’ordre des objets : reverse()
La fonction reverse() inverse l’ordre de tri. La fonction reverse_copy() copie le résultat du trie inverse dans une
autre séquence. (La fonction sort() trie dans ordre croissant)
•
void reverse(itrBidirectional prem, itrBidirectional dern);
• itrOutput reverse_copy(itrBidirectional prem, itrBidirectional der, ItrOutput
destination);
5.4 Mélanger les objets : random_shuffle()
La fonction random_shuffle() mélange les objets d'une séquence.
• void random_shuffle(ItrRandomAccess prem, ItrRandomAccess der);
Exemple 10 : Trie, trie partiel, inverse mélange
#include <iostream>
#include <vector>
// data source
int source[10]={2,3,7,5,4,1,8,0,9,6};
int main(void) {
vector<int> data(source, source+10);
ostream_iterator<int> ecran(cout," "); // itérateur adaptateur pour afficher
cout<<"Data origine"<< endl<<'\t';
cout << endl;
sort(data.begin(),data.end());
// Trie par ordre croissant
cout<<"Data TRIE"<< endl<<'\t';
cout << endl;
reverse(data.begin(),data.end());
// Trie dans l'ordre inverse
cout<<"Data TRIE en inverse"<< endl<<'\t';
cout << endl;
cout<<"Data MELANGE"<< endl<<'\t';
// Mélange
random_shuffle(data.begin(),data.end());
cout << endl;
// Trie par ordre croissant des 4 premiers objets
cout<<"Data TRIE partiel des 4 1ere"<< endl<<'\t';
partial_sort(data.begin(),data.begin()+4,data.end());
cout << endl;
return 0;
}
Data origine
2 3 7 5 4 1 8 0 9 6
Data TRIE
0 1 2 3 4 5 6 7 8 9
Data TRIE en inverse
9 8 7 6 5 4 3 2 1 0
Data MELANGE
5 6 9 7 3 2 1 0 4 8
Data TRIE partiel des 4 1ere
0 1 2 3 9 7 6 5 4 8
David Saint-Mellion
page 13/18
Langage C++
05/02/03
6 OPÉRATIONS DE COMPARAISON DE 2 SÉQUENCES
6.1 Tester l’égalité de contenu : equal()
La fonction equal() est la fonction de base. Elle compare deux séquences. Elle retourne la valeur true si les
deux séquences sont identiques. Il peut être spécifié une fonction binaire. Elle permet de tester uniquement
l'égalité de deux objets.
• bool equal(itrInput prem1, itrInput der1, itrInput prem2);
• bool equal(itrInput prem1, itrInput der1, itrInput prem2, predicateBinaire p);
6.2 Rechercher les objets dichotomiques (différents) : mismatch()
La fonction mismatch() renvoie la première position où les valeurs de deux séquences diffèrent. La valeur de
retour est une paire d’itérateurs : Si le contenu est différent la paire référence les deux objets différents dans
chaque séquence. Si le contenu est identique, la paire vaut itérateur dernier de chaque séquence.
• pair<itrInput1, itrInput2> mismatch(itrInput prem1, itrInput der1, itrInput
prem2);
• pair<itrInput1, itrInput2> mismatch(itrInput prem1, itrInput der1, itrInput
prem2, predicateBinaire p);
6.3 Tester l’infériorité - Comparaison lexicographique : lexicographical_compare()
La fonction lexicographical_compare() détermine si une séquence est inférieure à une autre séquence selon la
relation d'ordre lexicographique. L'ordre lexicographique est celui utilisé par le dictionnaire. Les objets sont
examinés un à un dans leur ordre d'apparition et la comparaison s'arrête dès que deux objets différents. La
valeur de retour vaut true si la première séquence est strictement plus petite que la deuxième. S’il y a égalité
totale, la plus petite est celle qui contient le moins d'objets.
• bool lexicographical_compare(itrInput prem1, itrInput der1, itrInput prem2,
itrInput der2);
• bool lexicographical_compare(itrInput prem1, itrInput der1, itrInput prem2,
itrInput der2, compare c);
Exemple 11 : Comparer 2 conteneurs
#include <iostream>
#include <vector>
// Data source
int source[10]={15,61,33,77,18,9,12,81,3,20};
int main(void) {
int tab[10] = {15,61,33,7,18,9,1200,81,3,20};
// Déclare et intialise le vecteur d'entiers
vector<int> vec(source, source+10);
// Déclare une variable paire :
//
- pointeur d'entier
//
- itérateur vector d'entier
pair<int*, vector<int>::iterator> positions;
// Teste si le tableau est égale au vecteur
if (equal(tab,tab+10,vec.begin()))
cout<<"Le contenu du tableau est identique a celui du vecteur"<<endl;
else{
// Recherche la première position où il y a différence
positions=mismatch(tab,tab+10,vec.begin());
// Affiche les différences
cout<<"La 1ere difference entre le tableau et le vecteur :"<<endl
<<'\t'<<"tab["
<<(positions.first-tab)<<"] vaut "
<<*positions.first<<endl;
cout<<'\t'<<"vec["
<<(positions.second-vec.begin())<<"] vaut "
David Saint-Mellion
page 14/18
Langage C++
05/02/03
<<*positions.second<<endl;
// Compare le contenu du tableau et du vecteur
if (lexicographical_compare(tab,tab+10,vec.begin(),vec.end()))
cout<<"- Le tableau est plus petit le vecteur"<<endl;
else
cout<<"- Le tableau est plus grand que le vecteur"<<endl;
}
return 0;
}
La 1ere difference entre le tableau et le vecteur :
tab[3] vaut 7
vec[3] vaut 77
- Le tableau est plus petit le vecteur
7 LES OPÉRATIONS ENSEMBLISTES SUR 2 SÉQUENCES
Les opérations ensemblistes sur 2 séquences permettent de :
• Tester l'inclusion d'une séquence dans une autre,
• Réaliser l’intersection : la sélection des objets communs, la fusion : le regroupement de tous objets,
l’union : la sélection des objets qui ne sont pas communs, la différence : la sélection des objets n’appartenant
qu’à une séquence.
Les fonctions set_xxx() prennent en compte la valeur des objets mais aussi l’ordre dans les séquences. Voir
exemple ci-dessous.
Opération
Intersection
Fusion
Union
Différence
Différence symètrique
Fonction
set_intersection()
merge()
set_union ()
set_difference()
set_symmetric_difference()
Séquence 1
1, 2, 3, 4
1, 2, 3, 4
1, 2, 3, 4
1, 2, 3, 4
1, 2, 3, 4
Séquence 2
3, 4, 2, 5
3, 4, 2, 5
3, 4, 2, 5
3, 4, 2, 5
3, 4, 2, 5
Résultat
3, 4
1, 2, 3, 4, 3, 4, 2, 5
1, 2, 3, 4, 2, 5
1, 2
1, 2, 2, 5
7.1 Vérifier l’inclusion d’une séquence dans une autre
La fonction includes() vérifie que toutes les valeurs d’une séquence sont dans une autre séquence. Un objet est
considéré présent dans une séquence s'il existe au moins un objet qui lui est identique. Une fonction binaire
peut être utilisée. La valeur retournée est true si tous les objets de la deuxième séquence sont également
présents dans la première séquence.
• bool includes(itrInput prem1, itrInput der1, itrInput prem2, itrInput der2);
• bool includes(itrInput prem1, itrInput der1, itrInput prem2, itrInput der2,
compare c);
7.2 Effectuer l’intersection de 2 séquences : set_intersection()
La fonction set_intersection() crée une copie de tous les objets de première séquence qui font également partie
de la seconde. Une fonction binaire peut être utilisée pour définir une autre relation que l'égalité.
• itrOutput set_intersection(itrInput prem1, itrInput der1, itrInput prem2,
itrInput der2, itrOutput destination);
• itrOutput set_intersection(itrInput prem1, itrInput der1, itrInput prem2,
itrInput der2, itrOutput destination, compare c);
7.3 Fusionner 2 séquences : merge()
La fonction merge() réalise la fusion des 2 séquences en créant une copie des objets des 2 séquences. La
séquence résultat est constituée par la concaténation des 2 séquences. Le nombre d'objets du résultat est égal
à la somme des nombres des objets des 2 séquences.
• itrOutput merge(itrInput prem1, itrInput der1, itrInput prem2, itrInput der2,
itrOutput destination);
• itrOutput merge(itrInput prem1, itrInput der1, itrInput itrOutput destination,
compare c);
David Saint-Mellion
page 15/18
Langage C++
05/02/03
7.4 Faire l’union de 2 séquences : set_union ()
La fonction set_union () crée une copie de l’union des 2 séquences. Les objets équivalents ne sont copiés qu’en
un exemplaire. La séquence résultat est constituée par la concaténation des objets de la première séquence et
de ceux qui sont différents de la seconde.
• itrOutput set_union(itrInput prem1, itrInput der1, itrInput prem2, itrInput
der2, itrOutput destination);
• itrOutput set_union(itrInput prem1, itrInput der1,
itrInput prem2, itrInput
der2, itrOutput destination,
compare c);
7.5 Fusionner au sein d’une séquence : inplace_merge()
La fonction inplace_merge() fusionne 2 séquences triées d'un conteneur.
•
void inplace_merge(itrBidirectional prem, itrBidirectional separation,
itrBidirectional der);
• void inplace_merge(itrBidirectional prem, itrBidirectional separation,
itrBidirectional der, compare c);
7.6 Etablir la différence de 2 séquences : set_difference(), set_ symmetric_difference()
La fonction set_difference() crée une copie des objets appartenant seulement à la première séquence.
• itrOutput set_difference( itrInput prem1, itrInput der1, itrInput prem2,
• itrOutput set_difference( itrInput prem1, itrInput der1, itrInput prem2,
itrInput der2, itrOutput destination,
compare c);
La fonction set_ symmetric_difference() crée une copie de l’union des différences en rassemblant les objets
appartenant seulement à la première séquence et seulement la deuxième séquence.
• itrOutput set_symmetric_difference( itrInput prem, itrInput der, itrInput prem,
• itrOutput set_symmetric_difference( itrInput prem1, itrInput der1, itrInput
prem2, itrInput der2, itrOutput destination,
compare c);
Exemple 12 : Opérations ensemblistes
#include <iostream>
#include <string>
#include <vector>
#include <list>
// pour string
// pour ptr_fun
bool paritePaire(int val){
return (val&0x00000001)==0;
}
void affiche(string str1, string str2, bool val){
if (val)
cout<<str1<<" contient "<<str2<<endl;
else
cout<<str1<<" ne contient pas "<<str2<<endl;
}
// Data source
int source1[8]={2,10,16,19,20,20,77,77};
int source2[10]={77,77,67,52,20,20,19,16,10,2};
int main(void){
int data[10]={80,81,96,97,0,82,89,90,90,97};
int tab[3]={16,20,77};
vector<int> vec(source1, source1+8);
David Saint-Mellion
page 16/18
Langage C++
05/02/03
list<int> liste(source2, source2+10);
vector<int> dest(18);
vector<int>::iterator itrDer=NULL; // Définit un itr pour un vector de int
// Teste l'inclusion et affiche le résultat
affiche("vec","liste",includes(vec.begin(),vec.end(),
liste.begin(),liste.end()));
affiche("vec","tab",includes(vec.begin(),vec.end(),tab,tab+3));
affiche("liste","tab",includes(liste.begin(),liste.end(),tab,tab+3));
// Effectue l'intersection de vec et de liste
itrDer=set_intersection(vec.begin(),vec.end(),
liste.begin(),liste.end(),dest.begin());
cout<<endl<<"Intersection de vec et de liste "<<endl<<"\t";
copy(dest.begin(),itrDer,ecran);
// Effectue l'union de vec et de liste
itrDer=set_union(vec.begin(),vec.end(),liste.begin(),
liste.end(),dest.begin());
cout<<endl<<"Union de vec et de liste "<<endl<<"\t";
// Effectue l'union de vec et de liste
itrDer=merge(vec.begin(),vec.end(),liste.begin(),liste.end(),
dest.begin());
cout<<endl<<"Fusion de vec et de liste "<<endl<<"\t";
// Effectue la différence de vec et de liste
itrDer=set_difference(vec.begin(),vec.end(),
cout<<endl<<"Difference de vec et de liste "<<endl<<"\t";
// Effectue la différence symétrique de vec et de liste
itrDer=set_symmetric_difference(vec.begin(),vec.end(),
cout<<endl<<"Difference symetrique de vec et de liste "<<endl<<"\t";
// Partitionne avec : critère "Nombre pair"
itrDer=partition(vec.begin(),vec.end(),ptr_fun(&paritePaire));
cout<<endl<<"Partitionne vec : critere-Nombre pair"<<endl<<"\t";
copy(vec.begin(),itrDer,ecran);
cout<<endl;
// Effectue la réunion des 2 séquences de data. Séparation au 4ème
inplace_merge(data,data+4,data+10);
cout<<"Reunion des 2 sequences de data"<<endl<<"\t";
copy(data,data+10,ecran);
cout<<endl;
return 0;
}
data : 80,81,96,97,0,82,89,90,90,97
vec : 2,10,16,19,20,20,77,77
liste : 77,77,67,52,20,20,19,16,10,2
tab : 16,20,77
// vec ne contient pas liste
// vec contient tab
// liste ne contient pas tab
//
// Intersection de vec et de liste
//
77 77
// Union de vec et de liste
//
2 10 16 19 20 20 77 77 67 52 20 20 19 16 10 2
David Saint-Mellion
page 17/18
Langage C++
//
//
//
//
//
//
//
//
//
//
05/02/03
Fusion de vec et de liste
2 10 16 19 20 20 77 77 77 77 67 52 20 20 19 16 10 2
Difference de vec et de liste
2 10 16 19 20 20
Difference symetrique de vec et de liste
2 10 16 19 20 20 67 52 20 20 19 16 10 2
Partitionne vec : critere-Nombre pair
2 10 16 20 20
Reunion des 2 sequences de data
0 80 81 82 89 90 90 96 97 97
7.7 Partitionner une séquence selon un critère : partition(), stable_partition()
La fonction partition() sépare les objets d'une séquence en deux sous-ensembles selon un critère. Les objets
vérifiant ce critère sont placés en tête, et les objets qui ne le vérifient pas sont placés à la fin. Les paramètres
sont les itérateurs référençant la séquence à partitionner, une fonction unaire déterminant si un objet vérifie le
critère de partitionnement. La valeur de retour est un itérateur repérant la position de la séparation entre les
deux sous-ensembles.
• itrForward partition(itrForward prem, itrForward der, predicate p);
L'opération de partitionnement avec partition() n'est pas stable : l'ordre relatif des objets de même valeur et sur
lesquels le prédicat du critère de partitionnement donne le même résultat n'est pas conservé.
La fonction stable_partition() garantit l'ordre relatif des objets au sein des sous-ensembles générés par
l'opération de partitionnement. C’est algorithme est plus complexe donc il mobilise plus de ressources.
•
itrForward stable_partition(itrForward prem, itrForward der, predicate p);
8 TABLE DES EXEMPLES DE CODE
Exemple 1 : Copier et afficher ........................................................................................................................... 3
Exemple 2 : Initialiser et échanger des objets .................................................................................................... 4
Exemple 3 : Supprimer des objets ..................................................................................................................... 5
Exemple 4 : Rechercher et remplacer des objets............................................................................................... 6
Exemple 5 : Parcourir et traiter les objets d’une séquence ................................................................................. 7
Exemple 6 : Compter des objets d’une séquence .............................................................................................. 8
Exemple 7 : Rechercher la position du Maxi et du Mini ...................................................................................... 9
Exemple 8 : Rechercher de positions - Occurrence et doublon ........................................................................ 10
Exemple 9 : Insérer une valeur dans une séquence triée................................................................................. 12
Exemple 10 : Trie, trie partiel, inverse mélange ............................................................................................... 13
Exemple 11 : Comparer 2 conteneurs.............................................................................................................. 14
Exemple 12 : Opérations ensemblistes............................................................................................................ 16
David Saint-Mellion
page 18/18

STL : La librairie Algorithm - David Saint

Transcription

Documents pareils

Les conteneurs STL

Je pratique le C++ 300

Transparents de la présentation II - CMAP

Table des matières

Cedrus atlantica (Endl.) Carr.

STL

Les transparents du cours 3

fichier pdf

le fil vert des enfants des enfants

soufflets circulaires cousus

conditions d`utilisation de nos pages internet