CKTIS / C++
Volledige en gedeeltelijke templatespecialisatie
Een templatespecialisatie levert een andere definitie voor specifieke argumenten of een familie van argumenten. Leer het verschil tussen volledige specialisatie met `template<>` en gedeeltelijke specialisatie, bijvoorbeeld voor `T*`, en de beperkingen voor functietemplates.
Versie: C++23; repository compiler flag, production runtime not attested
Syntax
template<class T> struct Kind { /* primary template */ };
template<> struct Kind<int> { /* full specialization */ };
template<class T> struct Kind<T*> { /* partial specialization */ };De primaire template levert de algemene definitie. Een volledige specialisatie (full specialization) levert een definitie voor één concrete verzameling argumenten; in het eenvoudige geval begint die met template<>. Een gedeeltelijke specialisatie (partial specialization) blijft een template: ze beschrijft een familie van overeenkomende argumenten, zoals Kind<T*> voor pointertypen. Het betekent niet simpelweg dat je enkele argumenten weglaat.
Klassentemplates en variabelentemplates kunnen gedeeltelijk worden gespecialiseerd, functietemplates niet. Functietemplates staan volledige specialisatie toe; voor families van argumenten gebruik je overloads, eventueel met constraints. Specialisatie is niet hetzelfde als expliciete instantiatie: template struct Kind<double>; vraagt om instantiatie van een bestaande definitie in plaats van een nieuwe definitie te leveren.
In het voorbeeld gebruikt Kind<double> de primaire template, past Kind<double*> bij de gedeeltelijke specialisatie en gebruikt Kind<int*> de volledige specialisatie. Als meerdere gedeeltelijke specialisaties overeenkomen, moet er precies één meest gespecialiseerde zijn; anders is het gebruik ambigu. Definities van klassenspecialisaties nemen niet automatisch leden van de primaire template over.
Declareer de primaire template vóór de specialisaties. Relevante specialisatiedeclaraties moeten bereikbaar zijn voordat gebruik instantiatie veroorzaakt, in elke toepasselijke vertaaleenheid; overtredingen van deze regels vereisen niet altijd een diagnose. Het voorbeeld is bedoeld voor lokale controle met -std=c++23. De bronnen zijn een werkdocument, geen bevroren C++23-editie.
Referentie-identificatoren die in dit item worden behandeld: full / partial specialization.
Voorbeelden
#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';
}
Resultaat
primary partial full
De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.