C++ Academy · Lektion

Typen abfragen

Typen zur Compile-Zeit untersuchen

Typen abfragen ist eine kostenlose C++ Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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 sind Type Traits?

Mit dem Header <type_traits> können Sie zur Compile-Zeit Fragen zu Typen stellen. Jedes Trait ist ein Template, das eine Konstante ::value oder einen Membertyp bereitstellt.

is_integral

std::is_integral<T>::value ist für Ganzzahltypen wie int und char true, andernfalls false.

#include <iostream>
#include <type_traits>

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

Die _v-Kurzform

C++17 hat _v-Variable-Templates eingeführt, sodass Sie statt ::value auch std::is_integral_v<T> schreiben können.

#include <iostream>
#include <type_traits>

int main() {
    std::cout << std::is_integral_v<long> << "\n";
    std::cout << std::is_floating_point_v<float> << "\n";
    return 0;
}

Kategorie-Traits

Viele Traits klassifizieren Typen.

is_pointer
is_reference
is_array
is_class
is_enum

#include <iostream>
#include <type_traits>

struct S {};

int main() {
    std::cout << std::is_pointer_v<int*> << "\n";
    std::cout << std::is_class_v<S> << "\n";
    std::cout << std::is_reference_v<int&> << "\n";
    return 0;
}

Beziehungs-Traits

Einige Traits vergleichen zwei Typen.

is_same<A,B>
is_base_of<Base,Derived>
is_convertible<From,To>

#include <iostream>
#include <type_traits>

struct Base {};
struct Derived : Base {};

int main() {
    std::cout << std::is_same_v<int, int> << "\n";
    std::cout << std::is_base_of_v<Base, Derived> << "\n";
    return 0;
}

Eigenschafts-Traits

Eigenschafts-Traits geben Qualifizierer und Fähigkeiten an.

is_const
is_signed
is_trivially_copyable
is_default_constructible

#include <iostream>
#include <type_traits>

int main() {
    std::cout << std::is_const_v<const int> << "\n";
    std::cout << std::is_signed_v<unsigned> << "\n";
    return 0;
}

Traits in static_assert verwenden

Traits lassen sich hervorragend mit static_assert kombinieren, um Anforderungen zur Compile-Zeit durchzusetzen.

#include <type_traits>
#include <iostream>

template <typename T>
T add(T a, T b) {
    static_assert(std::is_arithmetic_v<T>, "T must be a number");
    return a + b;
}

int main() {
    std::cout << add(2, 3) << "\n";
    return 0;
}

So funktionieren Traits

Ein Trait ist einfach ein Struct-Template. Das allgemeine Template erbt von false_type; eine Spezialisierung für den passenden Typ erbt von true_type. Der Compiler wählt die beste Übereinstimmung.

integral_constant

Alle booleschen Traits leiten sich von std::integral_constant ab. true_type und false_type sind lediglich Aliase dafür mit dem Wert value true beziehungsweise false.

#include <iostream>
#include <type_traits>

int main() {
    std::cout << std::true_type::value << "\n";
    std::cout << std::false_type::value << "\n";
    return 0;
}

Traits in Templates abfragen

Traits ermöglichen es Templates, abhängig von der Art des empfangenen Typs unterschiedliche Pfade zu wählen. So kann generischer Code int-, float-, Pointer- und Klassentypen unterschiedlich behandeln.

Nur zur Compile-Zeit

Abfragen von Traits verursachen keine Laufzeitkosten; sie werden während der Kompilierung ausgewertet. Das Ergebnis wird in den generierten Code eingebaut.

Kurzer Test

Rufen Sie sich die praktische Syntax von C++17 ins Gedächtnis.

Zusammenfassung

Sie haben gelernt, Typen abzufragen.

<type_traits> beantwortet Fragen zur Compile-Zeit
::value oder die _v-Kurzform liefert einen bool-Wert
Kategorie-, Beziehungs- und Eigenschafts-Traits
Kombinieren Sie sie mit static_assert, um Einschränkungen durchzusetzen

Häufig gestellte Fragen

Ist die Lektion „Typen abfragen“ kostenlos?

Ja — der vollständige Text von „Typen abfragen“ 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 „Typen abfragen“?

Typen zur Compile-Zeit untersuchen 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 1 von 4.

Wie lange dauert die Lektion „Typen abfragen“?

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