Introduction à la librairie standard STL

La classe vector est proche du tableau du C. Tous les éléments contenus dans le vector sont adjacents en mémoire, ce qui permet d’accéder immédiatement à n’importe quel élément. L’avantage majeur du vector comparé au tableau du C réside dans sa faculté à se réallouer automatiquement en cas de besoin lors de l’utilisation de la méthode push_back par exemple. La désallocation est également simplifiée de par l’existence du destructeur de classe. Cependant, contrairement à un tableau classique, une case n’est accessible par l’opérateur [] que si elle a été allouée au préalable (sinon une erreur de segmentation se déclenche).

L’exemple ci-dessous présente les principales méthodes issues de la classe vector

#include <vector>
#include <iostream>

int main()
{
  // Déclaration d'un vecteur d'entiers de taille non connue
  std::vector<int> myVector;

  // Ajout de trois éléments
  myVector.push_back(4);
  myVector.push_back(2);
  myVector.push_back(5);

  // La méthode size précise le nombre d'entrée courante
  for (unsigned int iEntry = 0; iEntry < myVector.size(); ++iEntry)
    std::cout << iEntry << " " << myVector[iEntry] << std::endl;

  // Création d'un vecteur d'entier contenant 70,70,70,70,70
  std::vector<int> mySecondVector(5,70);

  // Réassignation des valeurs de ce vecteur
  mySecondVector[0] = 5;
  mySecondVector[1] = 3;
  mySecondVector[2] = 7;
  mySecondVector[3] = 4;
  mySecondVector[4] = 8;

  mySecondVector.clear();
  return 0;
}

Parmi les quelques instructions présentées, on distingue l’utilisation de la méthode push_back qui permet d’ajouter un élément en fin de vecteur tout en réallouant l’espace mémoire nécessaire. La méthode push_front réalise l’opération inverse à savoir l’ajout d’une entrée en début de vecteur. Du fait du déplacement de l’ensemble des valeurs précédemment assignées et allouées en mémoire, cette méthode nécessite un temps plus conséquent afin de réorganiser la structure en mémoire du vecteur.

On note également l’utilisation de la méthode size qui permet de déterminer le nombre d’élément courramment alloué. Il est ainsi possible de parcourir l’ensemble des valeurs “recueillies” jusqu’à présent (nous verrons à la fin de ce cours, que la notion d’itérateur généralise ce mécanisme indépendamment de la classe mise en jeu).

Comme nous le soulignions précédemment, l’opérateur [] est également accessible rendant l’utilisation de la classe vector similaire au tableau. On remarquera toutefois qu’il existe la méthode at dont la finalité est identique à l’opérateur [] mais qui vérifie préalablement l’existence de l’élément. Dans le cas d’un dépassement de mémoire, le programme stoppe de manière plus élégante qu’un segmentation fault en précisant l’origine de l’arrêt. Enfin, la méthode clear permet de vider le vecteur de sa substance en ramenant sa taille à 0.

Il est possible en C++ d’utiliser les chaînes de caractères héritées du C. Celui-ci ne disposant pas de type “chaîne” primitif (c’est à dire intégré au langage), celles-ci sont représentées sous forme de tableaux de caractères terminés par un \0 (caractère ASCII 0). Le plus souvent, pour des raisons de souplesse, les chaînes sont allouées dynamiquement : le type de données représentant donc les chaînes de caractères en C est char* (qui signifie pointeur sur caractère ou pointeur sur tableau de caractères : on ne peut pas faire la différence en C). L’ensemble des manipulations classiques sur les chaînes de caractères est disponible à partir du fichier d’entête string.h (obtention de la longueur, concaténation, copie, segmentation,…).

Cependant, le fait d’utiliser une représentation aussi peu abstraite pose beaucoup de problèmes en pratique : le code n’est pas toujours lisible, et une certaine attention est requise pour gérer convenablement la mémoire sous peine d’obtenir des fuites mémoire ou, plus grave, des segmentation faults. Afin de manipuler plus aisément les chaîne de caractères, une classe string a été définie et intégrée dans la librairie standard.

Les chaînes de caractères se trouvent dans le header string (à ne pas confondre avec string.h, qui contient les fonctionnalités pour manipuler les chaînes de caractères C). L’exemple suivant présente quelques unes des possibilités offertes par cette classe

#include <string>
#include <iostream>

int main()
{
  // Assignation/copie de strings
  std::string myString1 = "abcd";
  std::string myString2 = myString1;
  // Initialisation de strings
  std::string myString3(myString2);

  // Concaténation
  myString2 += "abcd";
  std::string myString4 = myString1 + "toto";

  // Comparaison
  const bool myBoolean = (myString1 == myString2);
  if (myBoolean)
    std::cout << myString1 << " est identique à " << myString2 << std::endl;

  // Longueur d'un string
  unsigned int size = myString1.size();

  // Recherche dans un string
  unsigned int pos = myString1.find("bc");
  return 0;
}

On reconnaît entre autre la méthode size qui précise la taille i.e. le nombre de caractère, d’une instance de string. La surcharge des opérateurs tels que += ou + permet par ailleurs de concaténer des chaînes de caractères tandis que la méthode find indique la position à laquelle est trouvée la première occurence de la chaine de caractère fournie en argument.

Nous ne faisons ici, que citer certaines des méthodes les plus communément utilisées. Le lecteur intéressé pourra se référer aux nombreux ouvrage ainsi qu’aux différentes pages internet traitant du sujet. Nous soulignerons finalement la possibilité grâce au mécanisme des patrons de déclarer des vecteurs de chaines de caractères via l’instruction vector<string> myStringVector.