CKTIS / C++
Templates et concepts : paramètre de template contraint
Les templates décrivent des familles de fonctions ou de types, tandis que les concepts définissent des exigences pour les arguments de template. La déclaration template<Integer T> introduit un paramètre de type T soumis à Integer<T>, vérifié à la compilation et non à l’exécution.
Version : C++23; repository compiler flag, production runtime not attested
Syntaxe
template<typename T> concept C = /* bool constraint expression */;
template<C T> T identity(T value) { return value; }
// Alternative constraint placement:
// template<typename T> requires C<T>
// T identity(T value) { return value; }Un template décrit une famille de fonctions ou de types plutôt qu’une fonction ou un type concret. Un concept est un template qui définit des contraintes sur ses arguments. Dans l’exemple, Integer est une exigence nommée fondée sur std::integral<T> : elle accepte les types entiers, y compris bool, mais pas double. Un concept se définit à la portée d’un espace de noms, et non à l’intérieur d’une fonction.
Un paramètre de template contraint (constrained template parameter) dans template<Integer T> reste un paramètre de type, et non un objet ou une classe de base. Cette syntaxe introduit la contrainte Integer<T>. Pour la fonction présentée, template<typename T> requires Integer<T> exprime la même exigence. Ce sont des formes de déclaration alternatives, et non deux définitions à coller ensemble. Un simple template<typename T> n’impose pas cette contrainte.
Une clause requires attache une contrainte à une déclaration. Une expression requires, telle que requires(T x) { x + x; }, est au contraire une expression de type bool qui vérifie la validité des exigences écrites ; elle n’exécute pas x + x. Elle peut être utilisée dans une définition de concept. Un concept n’est ni une validation des données à l’exécution ni une preuve que tout le corps de la fonction est valide : satisfaire les contraintes n’exclut pas d’autres erreurs de compilation.
Dans l’exemple, identity(42) déduit T comme étant int et renvoie 42. Décommenter identity(3.5) rend la contrainte insatisfaite : cette surcharge n’est donc pas une candidate viable ; en l’absence d’une autre surcharge correspondante, l’appel est une erreur. L’exemple vise une compilation en C++23. La référence fournie est un projet de travail en évolution, et non une publication C++23 figée ; l’exemple n’utilise pas d’extensions plus récentes.
Exemples
#include <concepts>
#include <iostream>
template<typename T>
concept Integer = std::integral<T>;
template<Integer T>
constexpr T identity(T value) {
return value;
}
static_assert(Integer<int>);
static_assert(!Integer<double>);
static_assert(identity(42) == 42);
int main() {
std::cout << identity(42) << '\n';
// identity(3.5);
}
Résultat
42
Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.