C++, Qt, OpenGL, CUDA

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.

^ [[pile_et_tas|Chapitre précédent]] ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ [[algorithmes_standards|Chapitre suivant]] ^

====== Les conteneurs standards ======

Imaginons un instant que nous devions gérer une bibliothèque de livres sur le C++. Nous en avons beaucoup et nous voudrions en ajouter de nouveaux, en supprimer d'autres, en bref, faire comme dans la réalité. Pour commencer, résumons un livre par son nom et supposons que nous en avons 4. Le code suivant vous est peut-être venu à l'esprit.

<code>
string const premier_livre { "The C++ language" };
string const deuxieme_livre { "C++ Primer" };
string const troisieme_livre { "C++ concurrency in action" };
string const quatrieme_livre { "Qt 5 les essentiels" };
</code>

Maintenant, j'ai non plus 4 mais 15 livres. Va t-on vraiment créer 15 variables ? Et si j'ai 100 livres ? Non, ce n'est vraiment pas une bonne solution. En plus, le type ne change pas ; n'y aurait-il pas un moyen de ne pas à avoir à réécrire le type (+ d'éventuels attributs) X fois ? Heureusement, la bibliothèque standard nous fournit des outils formidables : les conteneurs.

========= Qu'est ce qu'un conteneur =========

Un conteneur est un outil fourni par la bibliothèque standard qui permet de regrouper autant d'éléments dénombrables de même type que l'on veut ; dans notre exemple, les livres sont bien de même type (string const) et son bien dénombrables. On parle de **collection** d'éléments. Et en plus de regrouper des informations de même type, un conteneur fournit les moyens de les modifier, d'en ajouter, d'en supprimer, de les compter, etc. Examinons tout cela.

========= Des conteneurs standards =========

La bibliothèque standard nous fournit plusieurs conteneurs, mais deux vont particulièrement retenir notre attention :

  * array : permet de stocker un nombre fixe d'éléments ;
  * vector : permet de stocker un nombre variable d'éléments ;

Il en existe [[http://www.cplusplus.com/reference/stl/|plusieurs autres]], mais ces deux-là sont parmi les plus utilisés et sont simples à comprendre. Et pour les utiliser, il faut commencer par les inclure avec les instructions suivantes (respectivement) :

  * #include <array>
  * #include <vector>

========= Initialisation =========

Commençons par std::array. Comme déjà dit, ce conteneur est une collection à taille fixe d'éléments. Il prend comme paramètres un type et une taille.

<code>
[const] std::array<type, taille> identificateur;
</code>

Quant à vector, sa taille est variable, il ne faut donc que le type.

<code>
[const] std::vector<type> identificateur;
</code>

Notez que, pour les deux conteneurs, il est possible de préciser l'attribut const ou non ; tout dépend de si la collection peut être modifiée ou non. Notez bien cependant que dans le cas de vector, s'il est déclaré avec const, alors il est impossible par la suite de rajouter ou de supprimer des éléments.

Si l'on reprend notre exemple de la bibliothèque, notre collection pourrait se faire ainsi :

<code>
std::array<std::string, 4> bibliotheque_array; // Si notre bibliothèque ne contient que 4 livres et uniquement 4
std::vector<std::string> bibliotheque_vector; // Si l'on veut ajouter ou supprimer des livres plus tard
</code>

Maintenant, passons à l'initialisation à proprement parler. Contrairement aux variables où {} suffisait, cette fois, il faut utiliser la forme {{}}, comme dans l'exemple ci-dessous :

<code>
std::array<std::string, 4> bibliotheque_array {{"The C++ language", "C++ Primer", "C++ concurrency in action", "Qt 5 les essentiels"}};

std::vector<std::string> bibliotheque_vector {{"The C++ language", "C++ Primer", "C++ concurrency in action", "Qt 5 les essentiels"}};
</code>





Même type, plusieurs éléments, dénombrable.

Un peu lourd à écrire, voir impossible si beaucoup d'élément

Définition conteneurs : collection d'éléments de même type. Dénombrable, notion de premier élément, de dernier élément, d'élément suivant, de nombre d'éléments.

Initialisation : avec initilizer-list

Fonction begin, end, next et size (prev, advance, distance)

Modification : push_back (emplace ? emplace_back ? insert ? pop_back ?)

Déréférencement * + cout/variable

code d'exemple avec array et vector. Différence compile time et runtime.

Existe d'autres conteneur, sera abordé plus tard et possible de créer ses propres conteneur (chapitre structure de données). Le plus important est de respecter la sémantique (ie la syntaxe permettant de les manipuler)

^ [[pile_et_tas|Chapitre précédent]] ^ [[programmez_avec_le_langage_c|Sommaire principal]] ^ [[algorithmes_standards|Chapitre suivant]] ^

{{tag> Cours C++}}
C++, Qt, OpenGL, CUDA

Outils d'utilisateurs

Outils du Site

Outils de la Page
