Fonctions de std::vector

Soyez le premier à donner votre avis sur cette source.

Vue 41 790 fois - Téléchargée 1 155 fois

Description

Ce code présente toutes les fonctions de std::vector et la spécialisation du vector<bool>
Pas de manière complètement exhaustive, mais un bon aperçu tout de même des possibilités de traitement d'un vecteur.

Source / Exemple :


// INCLUDE
#include <vector>								// Inclue la classe vector
#include <iostream>								// Pour l'utilisation de cout
#include <cassert>								// Pour les assertions
#include <valarray>								// Pour comparer un vecteur de booléen avec un valarray de booléen

// PROTOTYPE
void afficher(const std::vector<int>& VecteurAafficher);			// Fonction d'affichage de vecteur sur std::cout
void reinitialiser(std::vector<int>& VecteurAinitialiser);			// Réinitialise le vecteur avec des valeurs prédéfinies

// MAIN
void main()
{
	std::vector<int> MonVecteur;							// Déclaration de mon vecteur comme un vecteur d'entiers
	reinitialiser(MonVecteur);
	afficher(MonVecteur);

	std::vector<int> MonVecteur2;					// Déclaration de mon vecteur comme un vecteur d'entiers
	MonVecteur2.push_back(43500);
	MonVecteur2.push_back(4);
	MonVecteur2.push_back(36);

	// OPERATEUR [] (fonction membre operator []))
	// (1) Assigne une référence sur un élément du vecteur
	// (2) Assigne une référence constante sur un élément du vecteur
	std::cout << "[] (1)" << std::endl;
	int &element2=MonVecteur[1];							// Une fois la référence obtenue, j'ai accès en lecture/écriture à cet élément du vecteur
	std::cout << "Deuxieme element du vecteur est " << element2 << std::endl;
	element2=4810;											// Ayant obtenu une référence, toute modification sur la référence s'applique au deuxième élément du vecteur
	afficher(MonVecteur);
	MonVecteur[2]=2981;									// Je peux aussi directement attribué une valeur à un élément du vecteur, comme pour un tableau
	afficher(MonVecteur);
	MonVecteur.operator [](2)=2086;						// Cette expression permet de mieux voir [] comme une fonction membre (juste pour la remarque)
	afficher(MonVecteur);
	reinitialiser(MonVecteur);
	std::cout << "[] (2)" << std::endl;					// Nous obtenons maintenant une référence constante : nous avons un	accès en lecture seule
	const int &element1=MonVecteur[0];					// Le simple fait de mettre const fait comprendre au compilateur de renvoyer une référence constante
	std::cout << "Premier element du vecteur est " << element1 << std::endl;
	// element1=4102;									// lecture seule : pas de compilation de cette ligne
	// Se reporter aux commentaires d'Hylvenir
	

	// FONCTION ASSIGN
	// (1) Efface le contenu du vecteur et lui attribue celui d'un autre vector ou sous vector (compris entre les 2 itérateurs)
	// (2) Efface le contenu du vecteur et lui attribue une même valeur un certain nombre de fois
	std::cout << "ASSIGN (1)" << std::endl;
	MonVecteur.assign(MonVecteur2.begin(), MonVecteur2.end());
	afficher(MonVecteur);
	//MonVecteur.assign(MonVecteur2.end(), MonVecteur2.begin());			// Cas d'erreur (inversion des 2 itérateurs). Cette ligne provoque le "plantage" du programme.
	std::vector<int>::iterator Debut2=MonVecteur2.begin();		
	Debut2++;															// Debut2 est un pointeur sur le deuxième élément
	MonVecteur.assign(Debut2, MonVecteur2.end());
	afficher(MonVecteur);
	std::cout << "ASSIGN (2)" << std::endl;
	MonVecteur.assign(5,10);											// Mettre la valeur "10" 5 fois dans le vecteur
	afficher(MonVecteur);
	reinitialiser(MonVecteur);

	// FONCTION AT
	// (1) Renvoie une référence sur un élément du vecteur
	// (2) Renvoie une référence constante sur un élément du vecteur
	std::cout << "AT (1)" << std::endl;
	int &monat=MonVecteur.at(2);											// Récupère une référence sur le deuxième élément du vecteur
	std::cout << "3eme Element du vecteur : " << monat << std::endl;
	monat=74;																// C'est une référence, si je modifie monat je modifie aussi l'élément correspondant du vecteur
	afficher(MonVecteur);																// L'élément 2 du vecteur est passé à 74
	std::cout << "AT (2)" << std::endl;
	const int &monatconst=MonVecteur.at(0);									// Récupère une référence constante
	//monatconst=1;															// Je ne peux donc pas toucher à la valeur, cette ligne ne compile pas
	std::cout << "1er Element du vecteur : " << monatconst << std::endl;
	reinitialiser(MonVecteur);

	// FONCTION BACK
	// (1) Renvoie une référence modifiable sur le dernier élément
	// (2) Renvoie une référence non modifiable sur le dernier élément
	std::cout << "BACK (1)" << std::endl;
	int& i = MonVecteur.back( );
	std::cout << i << std::endl;
	i=999;
	afficher(MonVecteur);													// A partir du moment où j'obtiens une référence modifiable, je modifie i et la modification se répercute sur le dernier élément du vecteur
	std::cout << "BACK (2)" << std::endl;
	const int& j = MonVecteur.back();								// Comme j'ai mis le mot clé const, je vais obtenir une référence non modifiable
	// j = 888;													// -----> Je ne peux pas compiler cette ligne de code. j est en quelque sorte en lecture seule. 
																// Si on ne veut pas modifier le dernier élément du vecteur on a intérêt à utiliser cette référence constante
	std::cout << j << std::endl;
	reinitialiser(MonVecteur);

	// FONCTION BEGIN
	// (1) Renvoie un itérateur modifiable sur le premier élémént
	// (2) Renvoie un itérateur non modifiable sur le premier élément
	std::cout << "BEGIN (1)" << std::endl;
	std::vector<int>::iterator UnIterateur;						// Déclaration d'un itérateur sur un vecteur d'entiers
	UnIterateur = MonVecteur.begin();							// On lui attribue l'adresse du premier élément du vecteur
	std::cout << *UnIterateur << std::endl;						// Affichage du contenu du pointeur

  • UnIterateur = 777; // Modification du premier élément
std::cout << *UnIterateur << std::endl; // Affichage du contenu du pointeur UnIterateur++; // On pointe maintenant sur le deuxième élément std::cout << *UnIterateur << std::endl; // Affichage du contenu du pointeur std::cout << "BEGIN (2)" << std::endl; std::vector<int>::const_iterator UnIterateurConstant; // Déclaration d'un itérateur constant sur un vecteur d'entiers UnIterateurConstant = MonVecteur.begin(); std::cout << *UnIterateurConstant << std::endl; // Affichage du contenu du pointeur // *UnIterateurConstant = 666; // ---> Ca ne compile pas, le contenu du pointeur est protégé UnIterateurConstant++; // Ca par contre, je peux. Je me balade donc sur les éléments du vecteur, sans pouvoir les modifier std::cout << *UnIterateurConstant << std::endl; // Affichage du contenu du pointeur reinitialiser(MonVecteur); // FONCTION CAPACITY // (1) Renvoie le nombre d'élément que le vecteur pourrait contenir sans allouer plus de mémoire std::cout << "CAPACITY (1)" << std::endl; std::cout << "Capacite de MonVecteur : " << MonVecteur.capacity() << std::endl; MonVecteur.reserve(20); // Je réserve 20 places pour mon vecteur std::cout << "Capacite de MonVecteur : " << MonVecteur.capacity() << std::endl; std::cout << "Taille de MonVecteur : " << MonVecteur.size() << std::endl; // On peut ainsi voir la différente entre size(), le nombre d'éléments réellement occupés et capacity, le nombre total d'éléments réservés au vecteur afficher(MonVecteur); reinitialiser(MonVecteur); // FONCTION CLEAR // Vide le vecteur std::cout << "CLEAR" << std::endl; MonVecteur.clear(); afficher(MonVecteur); reinitialiser(MonVecteur); // FONCTION EMPTY // Dit si le vecteur est vide ou non std::cout << "EMPTY" << std::endl; if(MonVecteur.empty()!=true) std::cout << "Ce vecteur n'est pas vide" << std::endl; MonVecteur.clear(); if(MonVecteur.empty()==true) std::cout << "Ce vecteur est vide (on vient de faire un clear)" << std::endl; reinitialiser(MonVecteur); // FONCTION END // Equivalent de BEGIN pour la fin du vecteur ; attention end() pointe après le dernier élément du vecteur // FONCTION ERASE // (1) Efface un élément // (2) Efface une série d'éléments std::cout << "ERASE (1)" << std::endl; MonVecteur.erase(MonVecteur.begin()); // Efface le premier élément afficher(MonVecteur); reinitialiser(MonVecteur); std::cout << "ERASE (2)" << std::endl; MonVecteur.erase(MonVecteur.begin(),MonVecteur.end()); // Efface du premier au dernier élément (équivalent d'un clear) afficher(MonVecteur); reinitialiser(MonVecteur); // FONCTION FRONT // Equivalent BACK pour le début du vecteur // GET_ALLOCATOR // Récupère le système d'allocation utilisée par un vecteur pour par exemple fabriquer un nouveau vecteur sur la base de cette allocation std::cout << "GET_ALLOCATOR" << std::endl; std::vector<int> vecteurAllocationCommeMonVecteur(MonVecteur.get_allocator() ); std::vector<double> Unvecteuravecuneautreallocation; if(Unvecteuravecuneautreallocation.get_allocator().max_size()!=MonVecteur.get_allocator().max_size()) std::cout << "espace maximale alloue par int et double est different !" << std::endl; // INSERT // Insère de nouveaux éléments dans le vecteur std::cout << "INSERT (1)" << std::endl; std::vector<int>::iterator IteEndroitInsere=MonVecteur.end(); IteEndroitInsere--; // On va insérer le nouvel élément à l'avant dernière position MonVecteur.insert(IteEndroitInsere,42); afficher(MonVecteur); std::cout << "INSERT (2)" << std::endl; IteEndroitInsere=MonVecteur.begin(); MonVecteur.insert(IteEndroitInsere+2,4,1); // On insère 4 fois 1 au niveau de l'itérateur IteEndroitInsere afficher(MonVecteur); std::cout << "INSERT (3)" << std::endl; IteEndroitInsere=MonVecteur.begin(); MonVecteur.insert(IteEndroitInsere+4,MonVecteur2.begin(),--MonVecteur2.end()); // On insère tous les éléments du vecteur 2 sauf le dernier au niveau de l'itérateur IdeEndroitInsere afficher(MonVecteur); reinitialiser(MonVecteur); // MAX_SIZE // Renvoie la taille maximale que peut prendre le vecteur std::cout << "MAX_SIZE" << std::endl; std::cout << "Taille maximale du vecteur : " << MonVecteur.max_size() << std::endl; // POP_BACK // Efface le dernier élément du vecteur afficher(MonVecteur); MonVecteur.pop_back(); afficher(MonVecteur); reinitialiser(MonVecteur); // PUSH_BACK // Insère un élément à la dernière position du vecteur afficher(MonVecteur); MonVecteur.push_back(42); afficher(MonVecteur); reinitialiser(MonVecteur); // RBEGIN // Permet de parcourir le vecteur inversé // (1) Renvoie un itérateur modifiable sur le premier élémént du vecteur inversé // (2) Renvoie un itérateur non modifiable sur le premier élément std::cout << "RBEGIN (1)" << std::endl; std::vector<int>::reverse_iterator UnRIterateur; // Déclaration d'un reverse itérateur sur un vecteur d'entiers UnRIterateur = MonVecteur.rbegin(); // On lui attribue l'adresse du premier élément du vecteur inversé std::cout << *UnRIterateur << std::endl; // Affichage du contenu du pointeur
  • UnRIterateur = 777; // Modification du premier élément
std::cout << *UnRIterateur << std::endl; // Affichage du contenu du pointeur UnRIterateur++; // On pointe maintenant sur le deuxième élément std::cout << *UnRIterateur << std::endl; // Affichage du contenu du pointeur reinitialiser(MonVecteur); std::cout << "RBEGIN (2)" << std::endl; std::vector<int>::const_reverse_iterator UnRIterateurConstant; // Déclaration d'un itérateur constant sur un vecteur d'entiers UnRIterateurConstant = MonVecteur.rbegin(); std::cout << *UnRIterateurConstant << std::endl; // Affichage du contenu du pointeur // *UnRIterateurConstant = 666; //---> Ca ne compile pas, le contenu du pointeur est protégé UnRIterateurConstant++; // Ca par contre, je peux. Je me balade donc sur les éléments du vecteur inversé, sans pouvoir les modifier std::cout << *UnRIterateurConstant << std::endl; // Affichage du contenu du pointeur reinitialiser(MonVecteur); // REND // Permet de parcourir le vecteur inversé en fournissant un pointeur après le dernier élément du vecteur // (1) Renvoie un itérateur modifiable sur le dernier élémént du vecteur inversé // (2) Renvoie un itérateur non modifiable sur le dernier élément std::cout << "REND (1)" << std::endl; std::vector<int>::reverse_iterator UnRIterateurEnd; // Déclaration d'un reverse itérateur sur un vecteur d'entiers UnRIterateurEnd = MonVecteur.rend(); // On lui attribue l'adresse du premier élément du vecteur inversé std::cout << *UnRIterateurEnd << std::endl; // Affichage du contenu du pointeur : rend une valeur "fausse" puisque nous sommes en dehors du vecteur inversé UnRIterateurEnd--; // Modification du dernier élément (du vecteur inversé) std::cout << *UnRIterateurEnd << std::endl; // Affichage du contenu du pointeur UnRIterateurEnd--; // On pointe maintenant sur le deuxième élément std::cout << *UnRIterateurEnd << std::endl; // Affichage du contenu du pointeur UnRIterateurEnd--; // On pointe maintenant sur le troisième et dernier élément std::cout << *UnRIterateurEnd << std::endl; // Affichage du contenu du pointeur reinitialiser(MonVecteur); std::cout << "REND (2)" << std::endl; std::vector<int>::const_reverse_iterator UnRIterateurConstantEnd; // Déclaration d'un itérateur constant sur un vecteur d'entiers UnRIterateurConstantEnd = MonVecteur.rend(); UnRIterateurConstantEnd--; std::cout << *UnRIterateurConstantEnd << std::endl; // Affichage du contenu du pointeur // *UnRIterateurConstant = 666; //---> Ca ne compile pas, le contenu du pointeur est protégé UnRIterateurConstantEnd--; // Ca par contre, je peux. Je me balade donc sur les éléments du vecteur inversé, sans pouvoir les modifier std::cout << *UnRIterateurConstantEnd << std::endl; // Affichage du contenu du pointeur reinitialiser(MonVecteur); // RESERVE // Réserve de la place pour le vecteur std::cout << "RESERVE (1)" << std::endl; MonVecteur.reserve(20); // Je réserve 20 places pour mon vecteur (voir la fonction capacity) afficher(MonVecteur); reinitialiser(MonVecteur); // RESIZE // Redéfinit la taille du vecteur // (1) En indiquant la nouvelle taille // (2) En indiquant la nouvelle taille et la valeur des éléments à ajouter le cas échéant std::cout << "RESIZE (1)" << std::endl; MonVecteur.resize(10); // Nouvelle taille du vecteur : 10 afficher(MonVecteur); MonVecteur.resize(2); afficher(MonVecteur); std::cout << "RESIZE (2)" << std::endl; MonVecteur.resize(10,67); afficher(MonVecteur); MonVecteur.resize(4,68); // Deuxième paramètre superflu, puisque la nouvelle taille impose une réduction du vecteur afficher(MonVecteur); reinitialiser(MonVecteur); // SIZE // Renvoie la taille du vecteur std::cout << "SIZE (1)" << std::endl; std::cout << "La taille de MonVecteur est : " << MonVecteur.size() << std::endl; // SWAP // (1) Echange les éléments de deux vecteurs // (2) Echange les éléments de deux vecteurs (fonction amie) std::cout << "SWAP (1)" << std::endl; MonVecteur2.clear(); MonVecteur2.push_back(90); // Remplissage de MonVecteur2 MonVecteur2.push_back(25); MonVecteur2.push_back(39); MonVecteur2.push_back(70); MonVecteur.swap(MonVecteur2); afficher(MonVecteur); std::cout << "SWAP (2)" << std::endl; swap(MonVecteur,MonVecteur2); afficher(MonVecteur); // SPECIALISATION DU VECTEUR DANS LE CAS DE BOOLEENS // Un booléen du vecteur va être stocké sur un bit au lieu d'être stocké sur un octet // Pour vérifier cela, nous allons comparer la capacité d'un vecteur de booléens // et celle d'un vecteur de char (un char tenant sur un bit) std::cout << "Specialisation du vecteur dans le cas de booleens" << std::endl; std::vector<bool> VecteurLogique; std::vector<char> VecteurChar; VecteurLogique.push_back(true); VecteurChar.push_back('c'); std::cout << "Capacite vecteur logique : " << VecteurLogique.capacity() << std::endl; std::cout << "Capacite vecteur char : " << VecteurChar.capacity() << std::endl; // Avec l'affichage ci-dessus, nous remarquons que la capacité du vecteur logique est bien supérieure à celle du char // Typiquement celle du bool est de 32 et celle du char de 1 VecteurLogique.push_back(true); VecteurChar.push_back('c'); std::cout << "Capacite vecteur logique : " << VecteurLogique.capacity() << std::endl; std::cout << "Capacite vecteur char : " << VecteurChar.capacity() << std::endl; // L'ajout d'un bool ne modifie pas la capacité toujours à 32 for(int ind=0;ind<30;ind++) { VecteurLogique.push_back(true); VecteurChar.push_back('c'); } // Je complète le vecteur logique pour qu'il ait 32 valeurs (nous en avions déjà 2, je lui en mets 30 supplémentaires) std::cout << "Capacite vecteur logique : " << VecteurLogique.capacity() << std::endl; std::cout << "Capacite vecteur char : " << VecteurChar.capacity() << std::endl; // La capacité du vecteur logique est atteinte... VecteurLogique.push_back(true); VecteurChar.push_back('c'); // En rajoutant un élément, je la fais basculer à 64 (le bit "débordant" a provoqué l'allocation d'un nouvel octet de 32 bits où peuvent potentiellement être stockés 32 booléens) std::cout << "Capacite vecteur logique : " << VecteurLogique.capacity() << std::endl; std::cout << "Capacite vecteur char : " << VecteurChar.capacity() << std::endl; // La spécialisation de vector<bool> représente donc un gain de places // Voir la contre partie en lisant les commentaires de steve_clamage } // AFFICHER // Affiche tous les éléments de MonVecteur void afficher(const std::vector<int> &VecteurAafficher) { std::cout << "***" << std::endl; if(!VecteurAafficher.empty()) { std::vector<int>::const_iterator Iterateurvecteur; // Construction d'un itérateur pour parcourir les éléments du vecteur for(Iterateurvecteur=VecteurAafficher.begin();Iterateurvecteur!=VecteurAafficher.end();Iterateurvecteur++) { std::cout << "Valeur de l'iterateur : " << (*Iterateurvecteur) << std::endl; // L'itérateur est un pointeur sur un élément du vecteur. Pour avoir son contenu il faut donc mettre la petite étoile devant. } } else { std::cout << "le vecteur est vide" << std::endl; } std::cout << "***" << std::endl; } // REINITIALISER // Réinitialise le vecteur avec une série de nombre void reinitialiser(std::vector<int> &VecteurAinitialiser) { VecteurAinitialiser.clear(); VecteurAinitialiser.push_back(38); // On remplit le vecteur avec différents éléments par des "push_back" VecteurAinitialiser.push_back(26); // Chaque push_back ajoute un élément à le vecteur en le plaçant à la dernière position VecteurAinitialiser.push_back(73); }

Conclusion :


Voir aussi std::list http://www.cppfrance.com/code.aspx?id=29457 qui traite de std::list

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

Hylvenir
Messages postés
364
Date d'inscription
mercredi 11 février 2004
Statut
Membre
Dernière intervention
5 octobre 2006
2 -
Salut,
pas mal.
Mais c'est rigolo tu ne parles même pas de l'opérateur [] qui est quand même l'élément pour faire croire à un tableau C classique.
Et puis tu mets 'ne compile pas sous VC6' dans dans le code il y a #ifndef VC6. Pourquoi faire ? (à part désactiver certains bout de code. On le sait que VC6 c'est pas vraiment un compilo C++).
Ensuite tu parles de get_allocator, qui à mon avis sert très très peu souvent (en tout cas tu devrais mettre un exemple intéressant d'utilisation).
Enfin pour afficher(), t'aurais pu passer le std::vector à afficher en const &. ça aurait éviter la variable globale.
A+
guilhemmartincpp
Messages postés
29
Date d'inscription
mercredi 17 septembre 2003
Statut
Membre
Dernière intervention
9 janvier 2008
-
Salut,

merci pour tes remarques judicieuses.

Pour l'opérateur [], c'est normal car je parle juste des fonctions membres (comme indiqué dans le titre). Tu fais bien de le préciser ceci dit

En ce qui concerne la compilation VC6, tu as raison. En fait j'avais travaillé sous dotnet en essayant d'anticiper ce qui ne compilerait pas sous VC6. Après essai sous VC6 je me suis aperçu qu'il y avait encore plus de choses qui ne compilaient pas. Je corrigerai le tir à la prochaine maj en enlevant carrément le #define.

get_allocator, c'est noté, pour la prochaine maj, il y aura un exemple concret.

Pour afficher(), c'est tout à fait vrai, mais mon but ici était de présenter surtout les fonctions, donc je me suis permis d'utiliser une variable globale. Pour la prochaine maj donc, une amélioration.

Merci pour tes remarques constructives,

@plus
Guilhem.
Hylvenir
Messages postés
364
Date d'inscription
mercredi 11 février 2004
Statut
Membre
Dernière intervention
5 octobre 2006
2 -
c'est la première fois que je lis que l'opérateur [] du vector n'est pas une fonction membre.
pourtant dans le standard il est juste au dessus de at() ?
Hylvenir
Messages postés
364
Date d'inscription
mercredi 11 février 2004
Statut
Membre
Dernière intervention
5 octobre 2006
2 -
ah oui, (dommage je peux pas éditer mon précédent message)....
essaye pour voir :
(MonVecteur).operator[]( 0 );
ou relis la paragraphe 13.5.5 du standard ;)
bonne lecture :)
guilhemmartincpp
Messages postés
29
Date d'inscription
mercredi 17 septembre 2003
Statut
Membre
Dernière intervention
9 janvier 2008
-
Salut,

moi à la base, [], j'appelle ça un opérateur. D'où la nuance...

Guilhem.

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.