Stl : du tableau au conteneur vector
Soyez le premier à donner votre avis sur cette source.
Vue 9 350 fois - Téléchargée 320 fois
Description
L'exemple montre qu'un vector :
- Peut être utilisé comme un tableau
- Offre des services qui facilitent le codage: des opérateurs d'affectation
et de comparaison, des fonctions
- Remplace le tableau 'dynamique'
Dans le zip, un document pdf avec quelques explications sur le VECTOR
// --- Navré l'affichage alourdi un peu l'exemple ---
- Peut être utilisé comme un tableau
- Offre des services qui facilitent le codage: des opérateurs d'affectation
et de comparaison, des fonctions
- Remplace le tableau 'dynamique'
Dans le zip, un document pdf avec quelques explications sur le VECTOR
Source / Exemple :
//------------------------ STL : Le conteneur VECTOR ----------------------------
// Un vector peut être utilisé comme un tableau - Voir //1
// Un vector peut grossir ou 'maigrir' pendant l'exécution - Voir //2 et //3
// et remplace les tableaux à création dynamiques en sécurité
// Un vector utilise des itérateurs(itr): pointeurs 'intelligents'.
// - irtDebut=vector.begin() et irtFin=vector.end()
// - le dernier elts est à irtFin-1
// Un vector offre des services qui facilitent le codage:
// - des opérateurs d'affectations, de comparaison
// - des fonctions
// Un vector est déclaré pour un type d'objets, dans l'exemple limité au int
// Un vector est optimisé pour un ajout à la Fin.
//----------------------- David Saint-Mellion 22/01/2003 -----------------------
#include <iostream>
#include <vector>
using namespace std;
// data source
int tab[10]={100,22,33,4,555,600,7,80,9,11};
int main(void){
//----------------------------------------------- DECLARER un vector ---
// Définit un vector d'entier vide
vector<int> vec3;
// Définit un vector de 10 entiers
vector<int> vec2(10);
// Définit un vector initialise avec les valeurs de tab à (tab+10)-1
vector<int> vec1(tab, tab+10);
//1 ---------------------------------------- Un vector COMME un Tableau --
int i=0; // pour les for
cout<<"vec1 COMME un tableau "<<endl;
// Accéder aux membres avec l'opérateur []
cout<<'\t'<<"vec1 Premier:"<<vec1[0]
<<" Suivant:"<<vec1[1]
<<" Dernier:"<<vec1[9]<<endl;
vec1[1]=20000; // Modifie un elt
cout<<'\t'<<"vector vec1 : ";
// Parcourir pour faire quelque chose connaissant le nombre d'elts
for (i=0; i<10; i++) cout<<vec1[i]<<", ";
cout<< endl<<endl;
//2 ----------------------------------------- OPERATIONS entre vectors --
cout<<"OPERATIONS entre vectors"<<endl;
// Affecter vector a vector vec2<-vec1
vec2=vec1;
vec2[0]=10; // Affecte 2000 au 1er
cout<<'\t'<<"vector v2 : ";
for (i=0; i<10; i++) cout<<vec2[i]<<", ";
cout<<endl<<'\t';
// Comparer 2 vectors
if(vec2==vec1) // Teste l'égalité
cout<<"vec2=vec1"<<endl;
else if (vec2<vec1) // Teste si <
cout<<"vec2<vec1"<<endl;
else
cout<<"vec2>vec1"<<endl;
cout<<endl;
//3 -------------------------------------------- Faire GROSSIR le vector --
// Mieux que de créer un tableau dynamique
int taille =0;
int nbreElts=0;
// Définit un itérateur sur un vector d'entier
vector<int>::iterator itr;
cout<<"Faire GROSSIR le vector vec3 : ";
taille=vec3.capacity(); // Donne la capacité du vector
nbreElts=vec3.size(); // Donne le nombre d'elts dans le vector
cout<<" Capacite "<<taille<<" Nbre d'elts "<<nbreElts<<endl;
// Faire grossir un vector en ajoutant un elts avec push_back(val)
// Ajouter des membres à la fin du vector - Le vector s'étire
vec3.push_back(10); // Ajoute 1 elt à la Fin
vec3.push_back(2); // Ajoute 1 elt à la Fin
vec3.push_back(30); // Ajoute 1 elt à la Fin
cout<<'\t'<<"vector v3 : ";
// Parcourir pour faire quelque chose en utilisant un itr
// pour (itr de itrDebut_vec3 à itrDebut_vec3-1, au pas de 1,
// afficher valeur référencée par itr (* Renvoie la valeur référencée / itr)
for (itr=vec3.begin(); itr<vec3.end(); itr++) cout<<*itr<<", ";
taille=vec3.capacity();
nbreElts=vec3.size();
cout<<endl<<" "<<"vec3 Capacite "<<taille<<" Nombre d'elts "<<nbreElts<<endl;
cout<< endl;
//4 ---------------------------------------------- Faire MAIGRIR le vector --
cout<<"Faire 'MAIGRIR' le vector vec2 : ";
taille=vec2.capacity(); // Donne la capacité du vector
nbreElts=vec2.size(); // Donne le nombre d'elts dans le vector
cout<<" Capacite "<<taille<<" Nbre d'elts "<<nbreElts<<endl;
// Faire maigrir un vector en supprimant un elts avec pop_back()
// Efface des elts à la fin du vector - Le vector rétrécit
vec2.pop_back(); // Supprime 1 elt à la fin
vec2.pop_back(); // Supprime 1 elt à la fin
vec2.erase(vec2.end()-4,vec2.end());// Supprime 4 elt à la fin
cout<<'\t'<<"vector vec2 : ";
// Parcourir pour faire quelque chose en utilisant un itr
// pour (itr de itrDebut_vec2 à itrFin_vec2-1, au pas de 1,
// afficher la valeur référencée par itr
for (itr=vec2.begin(); itr<vec2.end(); itr++) cout<<*itr<<", ";
cout<< endl;
taille=vec2.capacity();
nbreElts=vec2.size();
cout<<" "<<"vec2 Capacite "<<taille<<" Nombre d'elts "<<nbreElts<<' ';
// Attention la capacité cad l'occupation en mémoire ne change pas
// Ce qui change, c'est irtFin
cout<<endl<<'\t'<<"vector vec2 : ";
for (itr=vec2.begin(); itr<vec2.end()+6; itr++) cout<<*itr<<", ";
cout<< endl;
vec2.clear();
cout<<'\t'<< "vec2.clear() "<<endl;
taille=vec2.capacity();
nbreElts=vec2.size();
cout<<" "<<"vec2 Capacite "<<taille<<" Nombre d'elts "<<nbreElts<<endl;
for (itr=vec2.begin(); itr<vec2.end(); itr++) cout<<*itr<<", ";
cout<< endl;
//5 -------------------------------------------------------------------- DIVERS --
cout<<"Divers"<<endl;
cout<<'\t'<<"vec1 Premier:"<<vec1.front() // front() accès au 1er
<<" Suivant:"<<*(vec1.begin()+1) // déréférence (itrDebut+1)
<<" Dernier:"<<vec1.back()<<endl; // back() accès au dernier
vec1.at(0)=8; //vec1[0]<-8
cout<<'\t'<<"vec1 Premier:"<<vec1.front()<<endl;
return 0;
}
//------------------- OPERATEURS et FONCTIONS UTILISEES dans l'EX -----------------
// = opérateur d'affectation
// == opérateur de comparaison égalité
// < opérateur de comparaison infériorité (tous les ops habituels sont dispo)
// [index] Accès direct indexé à la valeur d'un élément du vector (comme un tab)
// * déréférencement, renvoie la valeur référencée par l'itr
//
// front() Retourne la valeur du 1er elts
// back() Retourne la valeur du dernier elts
// pop_back() Retire le dernier elts
// push_back(val) Ajoute un elts a la fin et lui affecte val
// begin() Retourne l'itérateur DEBUT
// DEBUT : position du 1er elt du vector
// end() Retourne l'itérateur FIN
// FIN : position suivante après le dernier elt du vector
// size() Retourne le nombre d'elts contenus dans le vector
// capacity() Retourne la capacité (nombre d'elts possibles) du vector
// clear() Efface tous les elts du vector
// erase(itrPrem, itrDer) Efface les elts de irtPrem à itrDer-1
// at(index)=val Idem à [index] mais plus sur:
// Vérifie la type val et les limites (prévoir Trait Error)
// Non utilisé ici :
// resize (taille) Porte la capacité du vector à taille.
// reserve(taille) Augmente la capacité pour la porter à taille.
Conclusion :
// --- Navré l'affichage alourdi un peu l'exemple ---
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.