La bibliothèque Standard Template Library

Introduction

L’inventeur de C++, Bjarne Stroustrup, a travaillé sur des projets de développement très importants. Les premières applications de C++ ont été réalisées dans le domaine des télécommunications, domaine qui réclame des outils de haut niveau. Certes les classes favorisent l’abstraction, mais un programme n’est pas composé uniquement d’interfaces et d’implémentations.

À la conception du logiciel, le développeur doit déterminer la limite de réutilisation des réalisations précédentes. Derrière le terme réutilisation, on entend souvent le fait de copier/coller certaines parties de code source. Quels sont les éléments qui se prêtent le mieux à cette opération ? Les classes, naturellement, le modèle orienté objet étant construit autour du concept de réutilisation. Mais on trouve également des structures de données, des fonctions spécialisées, des pièces algorithmiques de natures diverses, n’étant pas encore parvenues à la maturité nécessaire à la formation de classes.

Les modules décrivent un découpage assez physique des programmes. Ainsi, un fichier de code source .h ou .cpp peut être considéré comme module....

Organisation des programmes

namespace Batiment 
{ 
  double longueur; 
 
  void mesurer() 
  { 
    longueur=50.3; 
  } 
} ; 
 
namespace Chaines 
{ 
 int longueur; 
 
  void calcule_longueur(char*s) 
  { 
    longueur=strlen(s); 
  } 
} ; 

int main(int argc, char* argv[]) 
{ 
  Batiment::mesurer(); 
  printf("La longueur du bâtiment est %g\n",Batiment::longueur); 
 
  using Chaines::longueur; 
  Chaines::calcule_longueur("bonjour"); 
  printf("La longueur de la chaîne est %d\n",longueur); 
  return 0; ...

Flux C++ (entrées-sorties)

La STL gère de nombreux aspects des entrées-sorties. Elle inaugure une façon de programmer pour rendre persistants les nouveaux types définis à l’aide du langage C++.

L’équipe qui l’a conçue à la fin des années 80 a eu le souci d’être conforme aux techniques en vigueur et de produire un travail qui résisterait au fil des ans.

Il faut reconnaître que la gestion des fichiers a énormément évolué depuis l’introduction de la bibliothèque standard : les bases de données relationnelles ont remplacé les fichiers structurés, et les interfaces graphiques se sont imposées face aux consoles orientées caractères.

Toutefois, les axes pris pour le développement de la STL étaient les bons. Si l’utilisation des flux est un peu tombée en désuétude, leur étude permet d’y voir plus clair pour produire une nouvelle génération d’entrées-sorties. Aussi, le terminal en mode caractères continue son existence, la vitalité des systèmes Linux en est la preuve.

Classe string pour la représentation des chaînes de caractères

C’est un fait étonnant, la majorité des traités d’algorithmie n’étudient pas les chaînes en tant que telles. La structure de données s’en rapprochant le plus reste le tableau pour lequel on a imaginé une grande quantité de problèmes et de solutions.

Le langage C est resté fidèle à cette approche et considère les chaînes comme des tableaux de caractères. Ses concepteurs ont fait deux choix importants : la longueur d’une chaîne est limitée à celle allouée pour le tableau, et le codage est celui des caractères du C, utilisant la table ASCII. Dans la mesure où il n’existe pas de moyen de déterminer la taille d’un tableau autrement qu’en utilisant une variable supplémentaire, les concepteurs du langage C ont imaginé de terminer leurs chaînes par un caractère spécial, de valeur nulle. Il est vrai que ce caractère n’a pas de fonction dans la table ASCII, mais les chaînes du C sont devenues très spécialisées, donc très loin de l’algorithmie générale.

L’auteur de C++, Bjarne Stroustrup, a souhaité pour son langage une compatibilité avec le langage C mais aussi une amélioration du codage prenant en compte différents formats de codage, ASCII ou non.

Conteneurs dynamiques

Une fonction essentielle de la bibliothèque standard est de fournir des mécanismes pour supporter les algorithmes avec la meilleure efficacité possible. Cet énoncé comporte plusieurs objectifs contradictoires. Les algorithmes réclament de la généricité, autrement dit des méthodes de travail indépendantes du type de données à manipuler. Le langage C utilisait volontiers les pointeurs void* pour garantir la généricité mais cette approche entraîne une perte d’efficacité importante dans le contrôle des types, une complication du code et finalement de piètres performances. L’efficacité réclamée pour STL. s’obtient au prix d’une conception rigoureuse et de contrôles subtils des types. Certes, le résultat est un compromis entre des attentes parfois opposées mais il est assez probant pour être utilisé à l’élaboration d’applications dont la sûreté de fonctionnement est impérative.

Les concepteurs de la STL ont utilisé les modèles de classes pour développer la généricité. Les modèles de classes et de fonctions sont étudiés en détail au chapitre Programmation orientée objet, et leur emploi est assez simple. Une classe est instanciée à partir de son modèle en fournissant les paramètres attendus, généralement le type de données effectivement pris en compte pour l’implémentation de la classe. Il faut absolument différencier cette approche de l’utilisation de macros (#define) qui provoque des résultats inattendus. Ces macros se révèlent très peu sûres d’emploi.

Une idée originale dans la construction de la bibliothèque standard est la corrélation entre les conteneurs de données et les algorithmes s’appliquant à ces conteneurs. Une lecture comparée de différents manuels d’algorithmie débouche sur la conclusion que les structures de données sont toujours un peu les mêmes, ainsi que les algorithmes s’appliquant à ces structures. Il n’était donc pas opportun de concevoir...

Travaux pratiques

L’interprète tiny-lisp s’appuie largement sur la STL. Voici des précisions sur la classe Variant implémentée à grand renfort d’objets issus de la bibliothèque standard.

1. La classe Variant

Variant est le type de données universel de tiny-lisp. Cela peut être un symbole, un nombre, une liste (de Variant), une procédure.

Dans tiny-lisp, l’objet Variant fait partie d’un environnement, un conteneur doté d’une table des symboles. Cette structure est nécessaire à l’exécution des fonctions et des lambda-expressions LISP pour passer les paramètres et créer des variables locales.

enum variant_type 
{ 
   Symbol, Number, List, Proc, Lambda, Chaine 
}; 
 
// definition à venir ; Variant et Environment se référencent mutuellement 
struct Environment;  
 
// un Variant représente tout type de valeur Lisp 
class Variant { 
public: 
 
   // fonction qui renvoie Variant et qui prend comme argument variants 
 
   typedef Variant(*proc_type) ( const std::vector<Variant>& ); 
 
   typedef std::vector<Variant>::const_iterator iter; 
    
   typedef std::map<std::string, Variant> map; 
 
   // types pris dans l'énumération : symbol, number, list, proc ou lamda 
   variant_type type;   
        
   // valeur scalaire 
   std::string val;     
        
   // valeur list 
   std::vector<Variant> list;  
 
   // valeur lambda 
   proc_type proc;      
    
   // environnement 
   Environment* env; 
    
   // constructeurs 
   Variant(variant_type type = Symbol) : type(type) , env(0), proc(0) { 
 
   } 
 
   Variant(variant_type type, const std::string& val) :  
type(type), val(val) , env(0) , proc(0) { 
    
   } 
    
   Variant(proc_type proc) : type(Proc), proc(proc)...