Stl : du tableau au conteneur vector

Soyez le premier à donner votre avis sur cette source.

Vue 8 933 fois - Téléchargée 307 fois

Télécharger le projet
Commenter

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

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 ---
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

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.

Du même auteur (cs_davidsm)