Templates

Un template est une entité C++ qui définit l'un des éléments suivants :

• une famille de classes ( class template ), qui peut être nested classes
• une famille de fonctions ( function template ), qui peut être member functions

Les modèles sont paramétrés par un ou plusieurs paramètres de modèle , de trois types : paramètres de modèle de type, paramètres de modèle constants et paramètres de modèle de modèle.

Lorsque des arguments de template sont fournis, ou, pour les templates de fonction et de classe (depuis C++17) uniquement, déduits, ils sont substitués aux paramètres du template pour obtenir une spécialisation du template, c'est-à-dire un type spécifique ou une lvalue de fonction spécifique.

Les spécialisations peuvent également être fournies explicitement : les spécialisations complètes sont autorisées pour les modèles de classe , de variable (depuis C++14) et de fonction, les spécialisations partielles sont uniquement autorisées pour les modèles de classe et les modèles de variable (depuis C++14) .

Lorsqu'une spécialisation de classe template est référencée dans un contexte qui nécessite un type d'objet complet, ou lorsqu'une spécialisation de fonction template est référencée dans un contexte qui nécessite l'existence d'une définition de fonction, le template est instancié (le code correspondant est réellement compilé), sauf si le template a déjà été explicitement spécialisé ou explicitement instancié. L'instanciation d'une classe template n'instancie aucune de ses fonctions membres sauf si elles sont également utilisées. Au moment de l'édition des liens, les instanciations identiques générées par différentes unités de traduction sont fusionnées.

La définition d'un modèle de classe doit être visible au point d'instanciation implicite, c'est pourquoi les bibliothèques de modèles fournissent généralement toutes les définitions de modèles dans les en-têtes (par exemple, la plupart des bibliothèques boost sont header-only ).

Syntaxe

Identifiants de template

Un identifiant de template a l'une des syntaxes suivantes :

Un identifiant de modèle simple qui désigne une spécialisation de modèle de classe désigne une classe.

Un identifiant de modèle qui nomme une spécialisation de modèle d'alias désigne un type.

Un identifiant de modèle qui nomme une spécialisation de modèle de fonction nomme une fonction.

Si toutes les conditions suivantes sont satisfaites, un identifiant de template est valide :

• Il y a au plus autant d'arguments que de paramètres ou un paramètre est un parameter pack (depuis C++11) .
• Il existe un argument pour chaque paramètre non-déductible non-pack (depuis C++11) qui n'a pas d'argument template par défaut.
• Chaque argument template correspond au paramètre template correspondant.
• La substitution de chaque argument template dans les paramètres template suivants (s'il y en a) réussit.

Un identifiant de modèle simple non valide est une erreur de compilation, sauf s'il nomme une spécialisation de fonction modèle (auquel cas SFINAE peut s'appliquer).

template<class T, T::type n = 0>
class X;
struct S
{
    using type = int;
};
using T1 = X<S, int, int>; // erreur : trop d'arguments
using T2 = X<>;            // erreur : pas d'argument par défaut pour le premier paramètre template
using T3 = X<1>;           // erreur : la valeur 1 ne correspond pas au paramètre de type
using T4 = X<int>;         // erreur : échec de substitution pour le second paramètre template
using T5 = X<S>;           // OK

template<typename T>
concept C1 = sizeof(T) != sizeof(int);
template<C1 T>
struct S1 {};
template<C1 T>
using Ptr = T*;
S1<int>* p;                      // error: constraints not satisfied
Ptr<int> p;                      // error: constraints not satisfied
template<typename T>
struct S2 { Ptr<int> x; };       // error, no diagnostic required
template<typename T>
struct S3 { Ptr<T> x; };         // OK, satisfaction is not required
S3<int> x;                       // error: constraints not satisfied
template<template<C1 T> class X>
struct S4
{
    X<int> x;                    // error, no diagnostic required
};
template<typename T>
concept C2 = sizeof(T) == 1;
template<C2 T> struct S {};
template struct S<char[2]>;      // error: constraints not satisfied
template<> struct S<char[2]> {}; // error: constraints not satisfied

Si toutes les conditions suivantes sont satisfaites, deux identifiants de template sont same :

• Leurs template-name s ou opérateurs font référence au même modèle.
• Leurs arguments de type de modèle correspondants sont du même type.
• Les valeurs des paramètres de modèle déterminées par leurs arguments de modèle constants correspondants sont template-argument-equivalent .
• Leurs arguments de modèle de modèle correspondants font référence au même modèle.

Deux identifiants de modèle identiques font référence à la même variable, (depuis C++14) classe ou fonction.

Entité template

Une entité template (ou, dans certaines sources, « temploïde ») est toute entité définie (ou, pour une expression lambda , créée) (depuis C++11) dans une définition de template. Toutes les entités suivantes sont des entités template :

• une classe/fonction /variable (depuis C++14) template

• un membre d'une entité template (comme une fonction membre non-template d'une classe template)
• un énumérateur d'une énumération qui est une entité template
• toute entité définie ou créée dans une entité template : une classe locale, une variable locale, une fonction amie, etc

Par exemple, dans

template<typename T>
struct A
{
    void f() {}
};

la fonction A::f n'est pas un modèle de fonction, mais est toujours considérée comme étant template.

Une fonction template est une fonction template ou une fonction qui est template.

Une classe template est un modèle de classe ou une classe qui est template.

Mots-clés

template , export

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi