Bibliothèques, modules et espaces de noms

1. Cartographier du code

Les espaces de noms n’ont pas d’incidence sur la compilation mais ils donnent une possibilité supplémentaire d’exprimer dans le programme des regroupements logiques, des unités d’action. Le code va pouvoir être cartographié selon des secteurs d’activité de façon claire. Plus un programme sera long et plus il aura besoin de répartir ses composants entre plusieurs espaces nommés. De plus, des conflits de noms entre éléments différents portant les mêmes noms peuvent être évités s’ils appartiennent à des espaces de noms différents. Cette répartition du code peut aussi convenir à un travail d’équipe, chacun apporte alors au programme l’espace de noms qu’il a élaboré sur tel ou tel aspect.

2. Accéder au contenu

Un espace de noms contient du code et le code contenu n’est visible que dans cet espace. L’instruction namespace permet d’écrire ses propres espaces de noms. La syntaxe est la suivante :

namespace monEspace{       // le nom de l'espace de noms 
 
     // ici les déclarations et les définitions de variables, 
     // fonctions, classes, objets... 
 
} 

L’accès du dehors aux éléments de l’espace de noms se fait ensuite avec l’opérateur d’accès :: (aussi utilisé pour localiser la déclaration d’une fonction dans une classe) :

    <nomEspace>::<nom de l'élément de l'espace de noms> 

Par exemple :

/*main.cpp*/ 
#include <iostream> 
 
namespace ToutpourlesChiens 
{ ...

1. Faciliter l’accès à un espace de noms

La directive using s’utilise souvent pour faciliter l’accès aux éléments d’un espace de noms. Elle peut cibler tous les éléments de l’espace de noms ou uniquement un élément particulier.

Par exemple, soit deux espaces de noms :

namespace E1 
{ 
    int v1; 
    void f1() {} 
}  
namespace E2 
{ 
    int v2; 
    void f2() {} 
} 
// directives using : 
using E1::v1;      // accès direct uniquement pour v1 dans E1 
using namespace E2;// accès direct pour tous les éléments de E2 
 
int main()  
{ 
    v1 = 10;     // utilise le using E1::v1 
    E1::f1();    // pas de using 
  
    v2 = 20;     // utilise le using 
    f2();        // général pour E2 
 
    return 0;  
} 

Un espace de noms anonyme a en réalité un nom caché attribué par la machine (par exemple $$$) et un using implicite est implémenté à partir de ce nom :

namespace perso 
{ 
    // espace de noms anonyme 
    namespace 
    { 
        void f(){ } 
 
    } 
    //using namespace $$$;  using implicite sur nom caché 
    void...

1. Principe

L’utilisation de la directive #include, qui remonte au début du langage C, est très ancienne. Quoique toujours en usage et probablement encore pour longtemps, elle pose cependant indéniablement quelques problèmes. Elle alourdit la compilation lorsqu’une bibliothèque est incluse un grand nombre de fois. Mais surtout, lorsqu’il y a des interdépendances entre données de plusieurs bibliothèques, l’ordre des inclusions peut s’avérer important et constituer une source de bogues s’il n’est pas respecté. C’est pourquoi C++ tend à s’en affranchir pour l’avenir en fournissant depuis peu un nouvel outil appelé module.

Un module est constitué de code compilé une fois pour toutes dans un fichier binaire. Tous les fichiers sources qui importent le module accèdent aux types et fonctions exportés qu’il contient directement en binaire, ce qui est beaucoup plus rapide que le traitement d’un fichier d’en-tête. Chaque module étant en quelque sorte autosuffisant une fois compilé, il n’y a pas d’interdépendance entre différents modules, ce qui permet des importations dans n’importe quel ordre.

En outre, les modules peuvent être utilisés conjointement avec des fichiers d’en-tête de bibliothèques afin d’assurer compatibilité et transition progressive vers cette nouvelle technique.

2. Créer une unité d’interface de module (.ixx)

Un module se compose d’un ou plusieurs fichiers. Il contiendra...