Vous ne trouvez pas de réponse à votre problème ? Alors posez la question dans le forum. Souvenez-vous qu'il n'y a jamais de question bête, mais rester dans l'ignorance parce que l'on n'ose pas poser une question, ça c'est une erreur !

FONCTIONS DE STD::VECTOR


Information sur la source

Catégorie :Tutoriaux Niveau : Débutant Date de création : 21/02/2005 Date de mise à jour : 02/03/2005 08:01:21 Vu / téléchargé: 29 705 / 944

Note :
5,67 / 10 - par 3 personnes
5,67 / 10

  • 1

  • 2

  • 3

  • 4

  • 5

  • 6

  • 7

  • 8

  • 9

  • 10

Commentaire sur cette source (22)
Ajouter un commentaire et/ou une note

Description

Cliquez pour voir la capture en taille normale
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

  • // 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);
  • }
// 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


 

Fichier Zip

Pour les "Membres Club", vous pouvez télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

Télécharger le zip

Historique

24 février 2005 20:43:01 :
Prise en compte des remarques d'Hylvenir (voir commentaires) : ajout de l'opérateur [] ; afficher et reinitialiser prennent maintenant un vecteur en paramètre ce qui permet de ne plus déclarer MonVecteur comme variable globale ; quelques lignes de plus sur get_allocator Suppression d'include qui n'avait rien à faire ici
02 mars 2005 08:01:22 :
Rajout de lignes sur la spécialisation du vector lorsque celui contient des valeurs logiques suivant la remarque de steve_clamage (optimisation de l'occupation mémoire).

Commentaires et avis

signaler à un administrateur
Commentaire de Hylvenir le 21/02/2005 20:44:52

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+

signaler à un administrateur
Commentaire de guilhemmartincpp le 21/02/2005 20:59:43

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.

signaler à un administrateur
Commentaire de Hylvenir le 21/02/2005 22:13:41

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() ?

signaler à un administrateur
Commentaire de Hylvenir le 21/02/2005 22:35:08

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 :)

signaler à un administrateur
Commentaire de guilhemmartincpp le 22/02/2005 07:24:38

Salut,

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

Guilhem.

signaler à un administrateur
Commentaire de Hylvenir le 22/02/2005 08:14:48

Salut (de bon matin),
ok.
Mais opérateur c'est plutôt une liée à la notation. (operator)
J'appelle ça aussi un opérateur mais ça n'empêche que c'est une fonction membre ( exemple operator[], operator += ) ou non membre ( operator +, operator *, ... ).

signaler à un administrateur
Commentaire de guilhemmartincpp le 22/02/2005 09:17:28

Ok, merci pour la précision.

Trouve-t-on le standard en ligne quelque part sur le web ?

Le vocabulaire que j'emploie est en fait celui de la MSDN, où [] est rangé comme opérateur, par "opposition" à par exemple at, rangé dans les fonctions membres.

signaler à un administrateur
Commentaire de Hylvenir le 22/02/2005 09:47:31

Il y a le draft quelque part...

http://www.csci.csusb.edu/dick/c++std/

tu devrais trouver des choses.

signaler à un administrateur
Commentaire de steve_clamage le 22/02/2005 18:34:24

ne pas oublier aussi de parler de la specialisation partielle au niveau du type de std::vector<bool>, trés important car dans certains cas il sera plus judicieux de choisir std::valarray<bool>

signaler à un administrateur
Commentaire de guilhemmartincpp le 24/02/2005 20:45:22


@Hylvenir : J'ai mis à jour de la source suivant tes remarques.

@steve_clamage : pourrais-tu développer un peu plus stp ? Merci.

@Tous : nouvelles remarques bienvenues

signaler à un administrateur
Commentaire de steve_clamage le 24/02/2005 21:14:38

L'implementation de vector<bool> est spéciale, le but est de permettre de stocker une grande quantité de valeurs logiques sur un minimun de place en mémoire, chaque bool est stoqué sur 1 bit au lieu d'un multiplet (byte)

Donc gain de place  mais moins performant pour les opérations courrantes sur un vector. Si tu veux utiliser une séquence de booléens pour appliquer des masques (ou autre traitements de masse) il vaut mieux utiliser std::valarray qui justement n'est pas implementé avec un vector (ce n'est pas un adaptateur de séquence) pour ces raisons.

signaler à un administrateur
Commentaire de steve_clamage le 24/02/2005 21:15:54

le liens sgi:

http://www.sgi.com/tech/stl/bit_vector.html

ils utilisent le nom (l'alias) bit_vector mais il est bien précisé que ce nom est déprécié.

signaler à un administrateur
Commentaire de guilhemmartincpp le 02/03/2005 08:03:41

Mise à jour de la source :

J'ai rajouté, à la fin du main, quelques lignes sur la spécialisation de vector<bool> suivant la remarque de steve_clamage

signaler à un administrateur
Commentaire de Gandi le 17/05/2007 02:45:15

Question: Comment fait on pour récupérer en une passe le tableau de données (un tableau une dimension [16] ), pour opengl dans mon cas
m_Matrice  = matrix<float>(4,4);
glMultMatrixf( m_Matrice.data.????);

si c'est pas le cas ubla c'est fait que pour de l'affichage texte --> aucun intéret pour le temps réel--> masturbation intellectuelle d'élitiste présonpteux (oui je suis assé énervé par la complexité et la lourdeure de cette lib..désolé).
Merci d'avance ;)

signaler à un administrateur
Commentaire de Hylvenir le 17/05/2007 12:39:37

Bah faut pas être énervé comme ça Gandi.

Comment ferais-tu en C ? ...
Et bien c'est pareil.
Sous réserve de ta description de matrix<float>
(parce que là, ça fait plutôt un tableau de float de taille 4 initialisé à 4.0... sauf erreur de ma part)

la réponse est donc (comme en C)

glMultMatrixf( &m_Matrice[0] )

Une propriété que doit avoir le std::vector est d'être un espace continu de donnée.

Sinon, oui la STL (ou SL) est outil qu'il faut appréhender par étape. C'est comme dire que le piano c'est pour les élites présomptueuses parce que j'ai pas réussi à faire "Sonate au Clair de Lune" de beethoveen en 3 jours...

Prends un bon livre (http://www.josuttis.com/libbook/)
et on verra après.

signaler à un administrateur
Commentaire de Gandi le 17/05/2007 14:03:52

Merci Hylvenir , désolé pour ce matin , à 3h du mat j'ai été un peu trops présomptueu de vouloir comprendre ce genre de chose . Merci pour le lien du livre je comptais justement m'en prendre un :p.

J'ai trouvé la solution
m_Matrice  = matrix<float,row_major,std::vector<float> >(4,4);

et pour y accéder j'ai fait comme ça
&(m_Matrice.data())[0]

j'ai essayé &m_Matrice[0] ça marche pas il n'y a as d'oppérateur crochet.
SI ça dérenge pas, je vais faire pare du soucis qu'il me reste.

m_Matrice  = matrix<float,row_major,std::vector<float> >(4,4);
m_Identite = identity_matrix<float>(4);

j'obtient une matrice nul comme si j'avais assigné  une zero_matrix.

signaler à un administrateur
Commentaire de Hylvenir le 17/05/2007 15:58:24

Malheureusement, je ne peux t'aider, l'objet matrix ne fait pas partie du C++, et je ne sais pas d'où cela vient.

Ce que j'ai écris étais valable pour std::vector

signaler à un administrateur
Commentaire de Gandi le 17/05/2007 16:09:33

oups désolé , j'étais complétement dans mon truc que j'ai oublié de dire c'était quoi (en plus j'était sur de que tu parlait de boost, encore désolé , ça m'apprendra à jongler entre plusieurs forums pour avoir la réponse )
boost::numeric::ublas::matrix
voici les liens:
Documention ublas :
http://www.boost.org/libs/numeric/ublas/doc/index.htm

Documention du type matrix:
http://www.boost.org/libs/numeric/ublas/doc/matrix.htm#matrix

Documentation du type du data des matrices par défaut:
http://www.boost.org/libs/numeric/ublas/doc/unbounded_array.htm
http://www.boost.org/libs/numeric/ublas/doc/storage_concept.htm
d'ailleur pas la peine de faire des std::vector ça marche aussi.

quand je disais des mechancetées c'était pour ublas , pas pour la std.
Merci pour ton aide . ;)

signaler à un administrateur
Commentaire de Hylvenir le 17/05/2007 19:39:14

J'suis pas un grand fan de boost pour le moment. Bon courage.

signaler à un administrateur
Commentaire de spidermario le 26/05/2007 12:41:48

Il est inutile d'écrire &xyz[0] car cela revient à écrire &(*xyz) et par conséquent xyz.

signaler à un administrateur
Commentaire de Sanke le 10/07/2007 14:45:45

Juste une petite précision concernant la partie :

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)

Un char n'est pas codé en 1 bit mais en 1 byte (octet en anglais), soit 8 bits pour des valeurs comprises entre -128 et 127.

Sinon code très interressant pour retrouver les prototypes des fonctions !

Bonne continuation







signaler à un administrateur
Commentaire de guilhemmartincpp le 15/07/2007 10:23:52

""" Un char n'est pas codé en 1 bit mais en 1 byte (octet en anglais), soit 8 bits pour des valeurs comprises entre -128 et 127. """


Merci Sanke pour la correction, c'est tout à fait judicieux. Il s'agit d'un lapsus de ma part.
Content que ça te soit utile.

Ajouter un commentaire



Nos sponsors

Sondage...

CalendriCode

Juillet 2009
LMMJVSD
  12345
6789101112
13141516171819
20212223242526
2728293031  

Consulter la suite du CalendriCode

Comparez les prix Nouvelle version

Photothèque Nouveau !



Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés
Temps d'éxécution de la page : 0,328 sec

Google Coop CodeS-SourceS Google Coop CodeS-SourceS


Certaines images présentes sur le site (notament certains avatars) sont issues des collections IconShock, donc si vous souhaitez utiliser ces icons vous devez les acheter, ne les copiez pas et ne utilisez pas dans vos sites et applications sans les avoir commandé.