Généricité, template, auto

Principe du template

Le template, nommé parfois patron ou modèle en français, associé à la fonction et à la classe dote le C++ d’un outil très puissant au fondement d’une programmation générique. Depuis C++11, notamment avec C++20, son utilisation s’affine et s’approfondit avec l’introduction de nouveaux mots-clés et les développements de la bibliothèque standard <concepts> (pour accéder aux fonctionnalités de C++20 sous Visual Studio se reporter au chapitre Premiers programmes, section Activer C++20).

Le template permet d’écrire des fonctions qui utilisent des paramètres ou une valeur de retour précisés au moment de l’appel de la fonction. Ce principe s’utilise aussi pour des classes qui peuvent recourir à des types d’éléments définis à la déclaration d’un objet. Typiquement, une classe pile par exemple, capable de produire des piles de n’importe quel type d’éléments, le type de l’élément est spécifié avec la déclaration d’un objet pile (pile de int, float, objets, etc.).

Les expressions template sont toujours définies en global hors bloc et évaluées à la compilation, de sorte qu’un template ne peut pas utiliser d’éléments dépendants de l’exécution du programme. Dans certaines expressions, la syntaxe du template apparaît un peu lourde et demande que l’on s’y habitue, presque comme s’il s’agissait d’un langage à part. La section Concepts (C++20) complète cet exposé avec des notions sur le renforcement de l’écriture des templates par l’introduction de "concept", nouveau mot-clé...

Template de fonction

En C++, les fonctions peuvent disposer d’un type générique de paramètre, c’est-à-dire des paramètres dont le type reste indifférent lors de la définition de la fonction mais qui sont déterminés plus tard avec l’appel de la fonction.

template <class nomType> 

template <class T> T fonct(T a, T b) 
{ 
    return (a<b) ? a : b; 
} 

#include <iostream> 
 
template <typename T> T fonct(T a, T b) 
{ 
    return (a<b) ? a : b; 
} 

int main() 
{ 
    // avec des float 
    std::cout << fonct(1.5f, 6.2f) << std::endl; 
 
    // avec des int 
    std::cout << fonct(200, 100) << std::endl; 
 
    // avec des char 
    std::cout << fonct('z', 'a') << std::endl; 
 
    std::cin.get(); 
    return 0; 
} 

Template de classe

template <class T> class maClasse  { ... }; 

template <typenanme T> class maClasse  { ... }; 

maClasse<int> e1; 

template <typename T> class maClasse 
{ 
    int val; 
 
    // déclaration propriété de type T 
    T valGenerique; 
 
    // déclaration ordinaire de fonction 
    void affiche(); 
 
    // fonction avec retour et un paramètre de type T 
    T fonct(int a, T b); 
}; 

Template variadique et paquet de paramètres

template<class...Arguments> 
void f(Arguments...arg) {/* contenu fonction */} 

template<typename...Arguments> 
void f(Arguments...arg) {/* contenu fonction */} 

template<typename ...Arguments>, 
template<typename... Arguments> 
template<typename ... Arguments> 

Argument... 

Arguments...args 

f (); 
f(10); 
f(1, 'A', 2.2, "Bonjour"); 
f("Resultat : "...

Utilités standards à base de templates

Voici sélectionnés quelques éléments génériques standards pratiques et instructifs élaborés en C++ avec des templates.

La classe générique bitset permet d’obtenir facilement un ensemble de bits utilisables comme un ensemble de booléens. Un objet bitset est plus facile à utiliser qu’une variable entière non signée.

Les classes génériques tuple et pair fournissent des ensembles de valeurs sans pour autant obliger à entrer dans les détails de l’implémentation d’une classe. Certes, une simple structure avec le nombre approprié d’éléments fonctionne parfaitement, mais cette alternative fournie en standard s’avère judicieuse dans de nombreuses situations.

Pour finir, nous proposons de visiter des classes inspirées de l’union, les classes variant, optional et any, qui interviennent dans certaines situations.

Pour ce qui concerne bitset, tuple et pair, des informations très complètes et très claires sont fournies sur https://cplusplus.com/reference/. Pour les variant, optional et any, il faut se reporter sur https://en.cppreference.com. Ces informations sont de qualité, mais pas toujours faciles d’accès à ceux qui ne connaissent pas déjà un peu les sujets.

Concepts (C++20)

Les techniques couvertes par la notion C++ de concept viennent renforcer et compléter l’écriture des templates afin de les rendre d’une part plus clairs et lisibles du point de vue du sens et d’autre part plus sûrs, plus sécurisés, dans leurs différents emplois possibles. Cet encadrement de l’écriture des templates s’exerce uniquement à la compilation des programmes. Il permet d’assurer une meilleure visibilité de problèmes potentiels pendant l’écriture de code générique et surtout d’éviter que ces problèmes ne se posent lors de l’exécution. Cette technique s’appuie sur l’utilisation de deux mots-clés, concept et requires, les opérateurs de conjonction ET (&&) et de disjonction OU (||) ainsi que sur l’exploitation de deux bibliothèques :

Les concepts, objet d’importants développements, deviennent avec la programmation générique un sujet très spécialisé qui s’adosse au langage C++ et mérite une étude complémentaire. D’autres bibliothèques contiennent maintenant des outils les concernant. Par exemple, à propos des traitements de séquences d’éléments, de tableaux ou de conteneurs, il y a les bibliothèques <iterator> et <range>.

Dans le cadre de cet ouvrage, nous nous en tenons à présenter les premières notions d’écriture de concepts, mais l’utilisation...

Spécification auto

auto d = 15 + 1.5; 

auto L = [=](int val) {return d + val; }; 

include<functional> 
std::function<double(int)> L = [=](int val) {return d + val; }; 

#include<iostream> 
#include<typeinfo> 
 
void fonct(auto a) { std::cout << typeid(a).name() << '\n'; } 
int main() 
{ 
    fonct('A');        // char 
    fonct(100);        // int 
    fonct(12.34);      // double 
 
    std::cin.get(); 
    return 0; 
} 

#include<iostream> 
#include<typeinfo> 
auto fonct()  
{  
    switch (rand() % 3) { 
    case 0: return 'A' + rand() % 26; break;        // oui int 
    case 1: return rand() % 100; break;             //...