La librairie standard STL

1. Espaces de noms

Le langage C ne connaît que deux niveaux de portée : le niveau global, auquel la fonction main() appartient, et le niveau local, destiné aux instructions et aux variables locales. Avec l’apparition de classes, un niveau supplémentaire s’est installé, celui destiné à l’enregistrement des champs et des méthodes. Puis l’introduction de la dérivation (héritage) et des membres statiques a encore nuancé la palette des niveaux de portée.

Pour les raisons évoquées en introduction, il devenait nécessaire de structurer l’espace global. Pour n’en retenir qu’une, l’espace global est trop risqué pour le rangement de variables et de fonctions provenant de programmes anciens. Les conflits sont inévitables.

On peut alors partitionner cet espace global à l’aide d’espaces de noms :

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

Deux espaces de noms, Batiment et Chaines, contiennent tous les deux une variable nommée longueur, d’ailleurs de type différent. Les fonctions mesurer() et calcule_longueur() utilisent toujours la bonne version, car la règle d’accessibilité est également vérifiée dans les espaces de noms : le compilateur cherche toujours la version la plus proche.

Pour utiliser l’une ou l’autre de ces fonctions, la fonction main() doit recourir à l’opération de résolution de portée :: ou bien à une instruction using :

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");  ...

1. Généralités

Pour bien commencer l’apprentissage des entrées-sorties, il faut faire la différence entre fichier et flux. Un fichier est caractérisé par un nom, un emplacement, des droits d’accès et parfois aussi un périphérique. Un flux (stream en anglais) est un contenu, une information qui est lue ou écrite par le programme. Cette information peut être de plus ou moins haut niveau. À la base, on trouve naturellement l’octet, puis celui-ci se spécialise en donnée de type entier, décimal, booléen, chaîne... Enfin, on peut créer des enregistrements composés d’informations très diverses. Il est tout à fait logique de considérer que la forme de ces enregistrements correspond à la formation d’une classe, c’est-à-dire d’un type au sens C++.

Les flux C++ (que l’on appelle parfois flots en langue française) sont organisés en trois niveaux. Le premier - le plus abstrait - regroupe les ios_base, format d’entrée-sortie indépendant de l’état...

1. Représentation des chaînes dans la librairie STL

Pour la librairie STL, une chaîne est un ensemble ordonné de caractères. Une chaîne s’apparente donc fortement au vector, classe également présente dans la bibliothèque. Toutefois, la chaîne développe des accès et des traitements qui lui sont propres, soutenant ainsi mieux les algorithmes traduits en C++.

Les chaînes de la bibliothèque standard utilisent une classe de caractères pour s’affranchir du codage. La librairie STL fournit le support pour les caractères ASCII (char) et pour les caractères étendus (wchar_t), mais on pourrait très bien envisager de développer d’autres formats destinés à des algorithmes à base de chaînes. Le génie génétique emploie des chaînes...

1. Opérations de séquence sans modification

Il s’agit principalement d’algorithmes de recherche et de parcours.

Nous proposons un exemple de recherche de valeur dans un vecteur de chaînes char* :

#include <iostream> 
#include <algorithm> 
#include <vector> 
using namespace std; 
   
int main(int argc, char* argv[]) 
{ 
  vector<char*> tab; 
  tab.push_back("Sonate"); 
  tab.push_back("Partita"); 
  tab.push_back("Cantate"); 
  tab.push_back("Concerto"); 
  tab.push_back("Symphonie"); 
  tab.push_back("Aria"); 
  tab.push_back("Prélude"); 
   
  vector<char*>::iterator pos; 
  char*mot="Concerto"; 
  pos=find(tab.begin(),tab.end(),mot); ...

1. Les lambda-expressions

En C++, une lambda-expression (ou lambda) est une fonction anonyme (désignée par le terme fermeture ou closure en anglais) appelée à l’endroit même où elle est définie. C’est un moyen pratique pour décrire des petits algorithmes sans chercher à rendre ces fonctions réutilisables.

La lambda est une notation composée des éléments suivants :

[capture] (paramètres) mutable exception { corps } 

La capture permet à la lambda de travailler avec les variables déclarées dans la portée qui la définit, en référence & ou en valeur =. La capture par défaut peut être par valeur =, ce qui signifie que la lambda reçoit une « copie » des variables apparaissant dans le corps d’instruction. Si la capture est par référence &, la lambda a la faculté de modifier les variables.

Les paramètres sont optionnels, bien que fréquemment une lambda reçoive des éléments à tester, à comparer, à évaluer, à traiter, etc.

Le mot-clé mutable est aussi optionnel. En règle générale, l’opérateur d’appel à une lambda est const par valeur, mais la présence de mutable annule cette règle, en permettant au corps d’instruction de modifier localement des variables capturées par valeur.

L’indication d’exception par throw ou noexcept est facultative, comme pour l’ensemble des fonctions C++.

Le type de retour est déduit par le compilateur à partir du corps. Par défaut, il s’agit de void, à moins qu’une...

1. Installation de la bibliothèque

Il existe plusieurs moyens d’installer la bibliothèque au sein d’un projet. Sous Linux, on peut suivre les instructions du site https://boost.org/ pour récupérer un package de sources ou de binaires.

Depuis Visual Studio, le moyen le plus direct consiste à télécharger un package NuGet. Depuis le menu Projet, utiliser la commande Gérer les packages NuGet. Indiquer boost dans la zone de recherche de l’onglet Parcourir. Le catalogue des packages présente alors la bibliothèque complète ainsi que des volumes de cette bibliothèque.

Après avoir cliqué sur le bouton Installer, le gestionnaire de package demande de confirmer l’installation de la bibliothèque au sein du projet :

La confirmation déclenche le processus de téléchargement du package NuGet (au niveau de la solution Visual Studio) et d’installation de la bibliothèque...

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...