CKTIS / C++
Spécialisation complète et partielle des templates
La spécialisation d’un template fournit une définition différente pour des arguments précis ou une famille d’arguments. Découvrez la différence entre la spécialisation complète avec `template<>` et la spécialisation partielle, par exemple pour `T*`, ainsi que les restrictions applicables aux templates de fonctions.
Version : C++23; repository compiler flag, production runtime not attested
Syntaxe
template<class T> struct Kind { /* primary template */ };
template<> struct Kind<int> { /* full specialization */ };
template<class T> struct Kind<T*> { /* partial specialization */ };Le template primaire fournit la définition générale. Une spécialisation complète (full specialization) fournit une définition pour un ensemble concret d’arguments ; dans le cas simple, elle commence par template<>. Une spécialisation partielle (partial specialization) reste un template : elle décrit une famille d’arguments correspondants, comme Kind<T*> pour les types pointeur. Cela ne signifie pas simplement omettre certains arguments.
Les templates de classes et de variables peuvent être partiellement spécialisés, contrairement aux templates de fonctions. Les templates de fonctions autorisent la spécialisation complète ; pour des familles d’arguments, utilisez des surcharges, éventuellement avec des contraintes. Une spécialisation n’est pas une instanciation explicite : template struct Kind<double>; demande l’instanciation d’une définition existante au lieu d’en fournir une nouvelle.
Dans l’exemple, Kind<double> utilise le template primaire, Kind<double*> correspond à la spécialisation partielle et Kind<int*> utilise la spécialisation complète. Lorsque plusieurs spécialisations partielles correspondent, il doit y en avoir une seule qui soit la plus spécialisée ; sinon, l’utilisation est ambiguë. Les définitions de spécialisations de classes ne récupèrent pas automatiquement les membres du template primaire.
Déclarez le template primaire avant ses spécialisations. Les déclarations des spécialisations concernées doivent être accessibles avant les utilisations qui déclenchent une instanciation, dans chaque unité de traduction applicable ; les violations de ces règles n’exigent pas toujours un diagnostic. L’exemple est destiné à une vérification locale avec -std=c++23. Les sources sont un projet en cours, et non une édition C++23 figée.
Identifiants de référence couverts par cette entrée : full / partial specialization.
Exemples
#include <iostream>
template<class T>
struct Kind {
static constexpr const char* name = "primary";
};
template<class T>
struct Kind<T*> {
static constexpr const char* name = "partial";
};
template<>
struct Kind<int*> {
static constexpr const char* name = "full";
};
int main() {
static_assert(Kind<double>::name[0] == 'p');
static_assert(Kind<double*>::name[0] == 'p');
static_assert(Kind<int*>::name[0] == 'f');
std::cout << Kind<double>::name << '\n'
<< Kind<double*>::name << '\n'
<< Kind<int*>::name << '\n';
}
Résultat
primary partial full
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.