C++ Academy · Lektion

Eigene Traits schreiben

Eigene Type Traits erstellen

Eigene Traits schreiben ist eine kostenlose C++ Academy-Lektion auf CoddyKit. Dies ist Lektion 4 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.

Eigene Traits erstellen

Wenn die Standardbibliothek die benötigte Abfrage nicht bereitstellt, können Sie ein eigenes Trait schreiben. Ein Trait ist einfach ein Template, das ::value oder ::type bereitstellt.

Primär-Template und Spezialisierung

Das Standardmuster besteht aus einem Primär-Template mit dem Standardwert false sowie einer Spezialisierung, die auf den gewünschten Typ passt und true setzt.

#include <iostream>
#include <type_traits>

template <typename T>
struct is_ptr : std::false_type {};

template <typename T>
struct is_ptr<T*> : std::true_type {};

int main() {
    std::cout << is_ptr<int>::value << "\n";
    std::cout << is_ptr<int*>::value << "\n";
    return 0;
}

Von integral_constant erben

Wenn Ihr Trait von std::true_type oder std::false_type erbt, erhält es automatisch ein value-Member und verhält sich wie die Standard-Traits.

Einen Container erkennen

Ermitteln Sie, ob ein Typ wie ein Container aussieht, indem Sie auf verschachtelte Member prüfen. Hier spezialisieren wir anhand des Vorhandenseins eines value_type-Typalias mithilfe eines Helfers.

#include <iostream>
#include <vector>
#include <type_traits>

template <typename T, typename = void>
struct has_value_type : std::false_type {};

template <typename T>
struct has_value_type<T, std::void_t<typename T::value_type>> : std::true_type {};

int main() {
    std::cout << has_value_type<std::vector<int>>::value << "\n";
    std::cout << has_value_type<int>::value << "\n";
    return 0;
}

std::void_t erklärt

std::void_t<...> bildet jede gültige Typenliste auf void ab. Ist einer der enthaltenen Typen nicht wohlgeformt, wird die Spezialisierung über SFINAE verworfen, sodass das primäre false_type greift.

Eine Memberfunktion erkennen

Sie können feststellen, ob ein Typ über eine aufrufbare size()-Funktion verfügt, indem Sie den Ausdruck in einem void_t testen.

#include <iostream>
#include <string>
#include <type_traits>

template <typename T, typename = void>
struct has_size : std::false_type {};

template <typename T>
struct has_size<T, std::void_t<decltype(std::declval<T>().size())>> : std::true_type {};

int main() {
    std::cout << has_size<std::string>::value << "\n";
    std::cout << has_size<int>::value << "\n";
    return 0;
}

declval

std::declval<T>() erzeugt in nicht ausgewerteten Kontexten einen künstlichen Wert vom Typ T. Dadurch können Sie decltype-Ausdrücke formulieren, ohne ein Objekt zu erzeugen.

Ein Transformations-Trait

Eigene Traits können auch Typen erzeugen. Dieses Trait entfernt eine Zeigerebene.

#include <iostream>
#include <type_traits>

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

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

int main() {
    using R = remove_one_pointer<int*>::type;
    std::cout << std::is_same_v<R, int> << "\n";
    return 0;
}

_v- und _t-Helfer bereitstellen

Übernehmen Sie den Stil der Standardbibliothek, indem Sie Variablen- und Alias-Templates hinzufügen.

#include <iostream>
#include <type_traits>

template <typename T>
struct is_char : std::false_type {};
template <>
struct is_char<char> : std::true_type {};

template <typename T>
inline constexpr bool is_char_v = is_char<T>::value;

int main() {
    std::cout << is_char_v<char> << "\n";
    std::cout << is_char_v<int> << "\n";
    return 0;
}

Detection Idiom

Die void_t-Technik lässt sich zum Detection Idiom verallgemeinern, das durch das experimentelle std::is_detected formalisiert wird. C++20-Konzepte machen vieles davon übersichtlicher.

Eigene Traits testen

Überprüfen Sie eigene Traits mit static_assert, damit jede Regression den Build sofort fehlschlagen lässt.

#include <type_traits>

template <typename T>
struct is_void_like : std::false_type {};
template <>
struct is_void_like<void> : std::true_type {};

static_assert(is_void_like<void>::value);
static_assert(!is_void_like<int>::value);

int main() { return 0; }

Kurze Überprüfung

Rufen Sie sich die Rolle von std::void_t in Erinnerung.

Zusammenfassung

Sie haben gelernt, eigene Traits zu schreiben.

Das Primär-Template verwendet standardmäßig false; die Spezialisierung setzt true
Erben Sie von true_type/false_type
void_t und declval bilden die Grundlage des Detection Idiom
Fügen Sie _v/_t-Helfer hinzu und testen Sie mit static_assert

Häufig gestellte Fragen

Ist die Lektion „Eigene Traits schreiben“ kostenlos?

Ja — der vollständige Text von „Eigene Traits schreiben“ 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 „Eigene Traits schreiben“?

Eigene Type Traits erstellen 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 4 von 4.

Wie lange dauert die Lektion „Eigene Traits schreiben“?

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