C++ Academy · Lektion

Typen umwandeln

remove_const, decay und mehr

Typen umwandeln 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.

Typtransformationen

Neben dem Abfragen kann <type_traits> aus vorhandenen neue Typen erzeugen. Diese Traits stellen einen Membertyp ::type bereit, mit einer _t-Kurzform ab C++14.

remove_const

std::remove_const_t<const int> ergibt int. Das ist nützlich, wenn Sie eine veränderbare Version eines Typs benötigen.

#include <iostream>
#include <type_traits>

int main() {
    using T = std::remove_const_t<const int>;
    std::cout << std::is_same_v<T, int> << "\n";
    return 0;
}

remove_reference

std::remove_reference_t<int&> ergibt int. Dies ist zentral für Perfect Forwarding und das Schreiben generischen Codes.

#include <iostream>
#include <type_traits>

int main() {
    using T = std::remove_reference_t<int&>;
    std::cout << std::is_same_v<T, int> << "\n";
    return 0;
}

add_pointer und add_const

Transformationen fügen auch Qualifizierer hinzu.

add_const_t<int> = const int
add_pointer_t<int> = int*

#include <iostream>
#include <type_traits>

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

std::decay

std::decay_t<T> bildet die Konvertierungen nach, die bei der Übergabe per Wert erfolgen: Es entfernt Referenzen und cv-Qualifizierer und konvertiert Arrays und Funktionen in Pointer.

#include <iostream>
#include <type_traits>

int main() {
    using T = std::decay_t<const int&>;
    std::cout << std::is_same_v<T, int> << "\n";
    return 0;
}

Array Decay

decay konvertiert einen Array-Typ in einen Pointer, genau wie bei der Übergabe eines Arrays an eine Funktion.

#include <iostream>
#include <type_traits>

int main() {
    using T = std::decay_t<int[5]>;
    std::cout << std::is_same_v<T, int*> << "\n";
    return 0;
}

remove_cv

std::remove_cv_t<const volatile int> entfernt sowohl const als auch volatile und ergibt den einfachen Typ int.

#include <iostream>
#include <type_traits>

int main() {
    using T = std::remove_cv_t<const volatile int>;
    std::cout << std::is_same_v<T, int> << "\n";
    return 0;
}

common_type

std::common_type_t<A,B> gibt den Typ an, in den beide konvertiert werden können, ähnlich dem Ergebnis von a + b.

#include <iostream>
#include <type_traits>

int main() {
    using T = std::common_type_t<int, double>;
    std::cout << std::is_same_v<T, double> << "\n";
    return 0;
}

underlying_type

Bei Enumerationen gibt std::underlying_type_t<E> den zugrunde liegenden Integer-Typ der Enumeration an.

#include <iostream>
#include <type_traits>

enum class Color : unsigned char { Red, Green };

int main() {
    using U = std::underlying_type_t<Color>;
    std::cout << std::is_same_v<U, unsigned char> << "\n";
    return 0;
}

Transformationen verketten

Transformationen lassen sich kombinieren. Um einen weitergeleiteten Typ zu normalisieren, kombinieren Sie sie häufig, z. B. remove_cv_t<remove_reference_t<T>>, was im Wesentlichen der erste Schritt von decay ist.

Warum Transformationen wichtig sind

Generische Funktionen erhalten häufig const T& oder T&&, benötigen aber den unveränderten Typ, um lokale Variablen oder Rückgabewerte zu deklarieren. Transformations-Traits liefern Ihnen diesen bereinigten Typ.

Kurzer Test

Rufen Sie sich ins Gedächtnis, was decay tut.

Zusammenfassung

Sie haben Typtransformationen gelernt.

Traits stellen ::type mit einer _t-Kurzform bereit
remove_const, remove_reference, remove_cv
add_pointer, add_const, decay
common_type, underlying_type für abgeleitete Ergebnisse

Häufig gestellte Fragen

Ist die Lektion „Typen umwandeln“ kostenlos?

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

remove_const, decay und mehr 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 „Typen umwandeln“?

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