C++ Academy · Lektion

Partielle Spezialisierung

Template-Muster spezialisieren

Partielle Spezialisierung ist eine kostenlose C++ Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C++ Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist eine partielle Spezialisierung?

Eine partielle Spezialisierung passt ein Template an eine Familie von Typen mit einem gemeinsamen Muster anstatt an genau einen Typ an.

Nur Klassen-Templates unterstützen sie.
Einige Parameter bleiben weiterhin generisch.

#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;
}

Zeiger abgleichen

Das Muster T* passt auf jeden Zeigertyp und ermöglicht es Ihnen, alle Zeiger mit einer einzigen Spezialisierung zu behandeln.

#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;
}

Funktionen können nicht partiell spezialisiert werden

Nur Klassen- und Variablen-Templates unterstützen die partielle Spezialisierung. Für Funktionen verwenden Sie stattdessen Überladungen.

#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;
}

Einen von zwei Parametern spezialisieren

Bei mehreren Typparametern können Sie einen festlegen und den anderen offenlassen, um ein Muster über verschiedene Typen hinweg abzugleichen.

#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 abgleichen

Sie können Arraytypen mit einem Muster abgleichen, das den Elementtyp und die Größe als Nicht-Typ-Templateparameter erfasst.

#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-Muster

Eine Spezialisierung kann const entfernen oder erkennen, indem sie const T als Muster abgleicht.

#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;
}

Die spezifischste Spezialisierung gewinnt

Wenn mehrere Spezialisierungen passen könnten, wählt der Compiler die spezifischste aus, also das Muster mit den genauesten Vorgaben.

#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;
}

Referenzmuster

Sie können auch Referenztypen abgleichen und dabei eine Referenz von einem einfachen Wert unterscheiden.

#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;
}

Typmerkmale erstellen

Die partielle Spezialisierung bildet die Grundlage von Typmerkmalen. Hier ist eine selbst implementierte Version von 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;
}

Muster kombinieren

Sie können Muster kombinieren, etwa einen Zeiger auf const abgleichen, um verschachtelte Typstrukturen zu behandeln.

#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;
}

Ein praktisches Container-Typmerkmal

Verwenden Sie eine partielle Spezialisierung, um den Elementtyp eines containerähnlichen Templates zu extrahieren.

#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;
}

Schnelltest

Testen Sie Ihr Verständnis der partiellen Spezialisierung.

Zusammenfassung

Sie haben die partielle Spezialisierung kennengelernt:

Sie passt ein Klassen-Template an ein Typmuster wie T* oder const T an
Für Funktionen verwenden Sie Überladungen und keine partielle Spezialisierung
Die spezifischste passende Variante wird ausgewählt
Sie bildet die Grundlage von Typmerkmalen wie remove_pointer

Als Nächstes lernen Sie SFINAE kennen, eine Möglichkeit, Funktionen nur dann zu aktivieren, wenn ein Typ die Voraussetzungen erfüllt.

Häufig gestellte Fragen

Ist die Lektion „Partielle Spezialisierung“ kostenlos?

Ja — der vollständige Text von „Partielle Spezialisierung“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C++ Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Partielle Spezialisierung“?

Template-Muster spezialisieren Du übst C++ Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C++ Academy zu starten?

Keine Vorkenntnisse erforderlich. C++ Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Partielle Spezialisierung“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C++ Academy-Lektion Code schreiben und ausführen?

Ja. Jede C++ Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu C++ Academy