C++ Academy · Les

Gedeeltelijke specialisatie

Specialiseer templatepatronen

Les 2 van 413 stappen

Gedeeltelijke specialisatie is een gratis C++ Academy-les op CoddyKit. Dit is les 2 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject C++ Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus C++ Academy bevat in totaal 4 lessen.

Wat is gedeeltelijke specialisatie?

Gedeeltelijke specialisatie past een template aan voor een familie van typen met een gedeeld patroon, in plaats van voor één exact type.

Alleen klassentemplates ondersteunen dit.
Je laat nog steeds enkele parameters generiek.

#include <iostream>

template <typename T>
struct Traits { static const char* kind() { return "value"; } };

template <typename T>
struct Traits<T*> { static const char* kind() { return "pointer"; } };

int main() {
    std::cout << Traits<int>::kind() << '\n';
    std::cout << Traits<int*>::kind() << '\n';
    return 0;
}

Pointers herkennen

Het patroon T* komt overeen met elk pointertype, zodat je alle pointers met één specialisatie kunt afhandelen.

#include <iostream>

template <typename T>
struct Deref { static T get(T v) { return v; } };

template <typename T>
struct Deref<T*> { static T get(T* p) { return *p; } };

int main() {
    int x = 42;
    std::cout << Deref<int>::get(7) << '\n';
    std::cout << Deref<int*>::get(&x) << '\n';
    return 0;
}

Functies kunnen niet gedeeltelijk worden gespecialiseerd

Alleen klasse- en variabeletemplates ondersteunen gedeeltelijke specialisatie. Voor functies gebruik je in plaats daarvan overloading.

#include <iostream>

template <typename T>
void show(T) { std::cout << "value\n"; }

template <typename T>
void show(T*) { std::cout << "pointer\n"; }

int main() {
    int x = 0;
    show(5);
    show(&x);
    return 0;
}

Eén van twee parameters specialiseren

Met meerdere typeparameters kun je er één vastleggen en de andere openlaten, zodat je een patroon over verschillende typen kunt herkennen.

#include <iostream>

template <typename A, typename B>
struct Pair { static const char* kind() { return "mixed"; } };

template <typename A>
struct Pair<A, A> { static const char* kind() { return "same types"; } };

int main() {
    std::cout << Pair<int, double>::kind() << '\n';
    std::cout << Pair<int, int>::kind() << '\n';
    return 0;
}

Arrays herkennen

Je kunt arraytypen herkennen met een patroon dat het elementtype en de grootte als een niet-typeparameter vastlegt.

#include <iostream>

template <typename T>
struct Info { static int size() { return 1; } };

template <typename T, int N>
struct Info<T[N]> { static int size() { return N; } };

int main() {
    std::cout << Info<int>::size() << '\n';
    std::cout << Info<int[5]>::size() << '\n';
    return 0;
}

Const-patronen

Een specialisatie kan const verwijderen of detecteren door const T als patroon te gebruiken.

#include <iostream>

template <typename T>
struct IsConst { static const bool value = false; };

template <typename T>
struct IsConst<const T> { static const bool value = true; };

int main() {
    std::cout << std::boolalpha;
    std::cout << IsConst<int>::value << '\n';
    std::cout << IsConst<const int>::value << '\n';
    return 0;
}

De meest specifieke wint

Wanneer meerdere specialisaties kunnen overeenkomen, kiest de compiler de meest gespecialiseerde: het patroon dat het meest specifiek is.

#include <iostream>

template <typename T>
struct K { static int v() { return 0; } };

template <typename T>
struct K<T*> { static int v() { return 1; } };

template <>
struct K<int*> { static int v() { return 2; } };

int main() {
    std::cout << K<double*>::v() << ' ' << K<int*>::v() << '\n';
    return 0;
}

Referentiepatronen

Je kunt ook referentietypen herkennen, zodat je een referentie van een gewone waarde kunt onderscheiden.

#include <iostream>

template <typename T>
struct Cat { static const char* k() { return "value"; } };

template <typename T>
struct Cat<T&> { static const char* k() { return "lvalue ref"; } };

int main() {
    std::cout << Cat<int>::k() << '\n';
    std::cout << Cat<int&>::k() << '\n';
    return 0;
}

Typekenmerken bouwen

Gedeeltelijke specialisatie vormt de basis van typekenmerken. Hier zie je een zelfgeschreven remove_pointer.

#include <iostream>
#include <type_traits>

template <typename T>
struct RemovePtr { using type = T; };

template <typename T>
struct RemovePtr<T*> { using type = T; };

int main() {
    std::cout << std::boolalpha;
    std::cout << std::is_same<RemovePtr<int*>::type, int>::value << '\n';
    return 0;
}

Patronen combineren

Je kunt patronen combineren, bijvoorbeeld door een pointer naar const te herkennen om gelaagde typestructuren af te handelen.

#include <iostream>

template <typename T>
struct Desc { static const char* k() { return "plain"; } };

template <typename T>
struct Desc<const T*> { static const char* k() { return "ptr to const"; } };

int main() {
    std::cout << Desc<int>::k() << '\n';
    std::cout << Desc<const int*>::k() << '\n';
    return 0;
}

Een praktisch containerkenmerk

Gebruik een gedeeltelijke specialisatie om het elementtype van een containerachtig template te extraheren.

#include <iostream>
#include <type_traits>

template <typename C>
struct Element { using type = void; };

template <template <typename> class C, typename T>
struct Element<C<T>> { using type = T; };

template <typename T>
struct Box { T item; };

int main() {
    std::cout << std::boolalpha;
    std::cout << std::is_same<Element<Box<int>>::type, int>::value << '\n';
    return 0;
}

Korte controle

Test je begrip van gedeeltelijke specialisatie.

Beantwoord dit in de interactieve les

Samenvatting

Je hebt geleerd over gedeeltelijke specialisatie:

past een klassentemplate aan voor een patroon van typen, zoals T* of const T
functies gebruiken overloading, geen gedeeltelijke specialisatie
de meest gespecialiseerde overeenkomende versie wordt gekozen
vormt de basis voor typekenmerken zoals remove_pointer

Vervolgens leer je SFINAE, een manier om functies alleen beschikbaar te maken wanneer een type aan de voorwaarden voldoet.

Gratis beginnen

Leer C++ met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 51
Lessen: 203

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Gedeeltelijke specialisatie” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad C++ Academy, waaronder “Gedeeltelijke specialisatie”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus C++ Academy bevat in totaal 4 lessen.

Wat leer ik in “Gedeeltelijke specialisatie”?

Specialiseer templatepatronen Je oefent met C++ Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met C++ Academy te beginnen?

Ervaring vooraf is niet nodig. C++ Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “Gedeeltelijke specialisatie”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over C++ Academy?

Ja. Elke les over C++ Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar C++ Academy