Das auto keyword

Table of Contents

Motivation

Wenn man lange mit dynamisch typisierten Sprachen wie Python gearbeitet hat, empfindet man
Sprachen, die eine explizite Typangabe zur Compile-Zeit verlangen, komplizierter und langsamer in der Implementierung.

Aber halt: in C++ hat sich seit C++11 einiges getan.

Wie war es früher?

Vor C++11 musste der Datentyp einer Variablen immer explizit angeben werden:

int age = 42;
double weight = 86.6;
const char* name = "Joern";

auto sagt dem Compiler: “Bestimme den Typ selbst, basierend auf der Initialisierung.”
Das bedeutet aber auch, dass Variablen immer direkt initialisiert werden müssen!

auto age = 42;
auto weight = 86.6;
auto name = "Joern";

Den inferierten Typ können wir mit der Funktion typeid ausgeben lassen:

std::cout << typeid(age).name() << std::endl;
std::cout << typeid(weight).name() << std::endl;
std::cout << typeid(name).name() << std::endl;

Dies gibt Folgendes aus:

i
d
PKc

Kurzer Ausflug – Name Mangling

Name Mangling ist der Vorgang, bei dem der C++-Compiler Funktions- und Klassennamen intern kodiert, um zusätzliche Informationen wie Parameterlisten, Namespaces oder Templates in den Symbolnamen einzubetten. Dadurch können z. B. überladene Funktionen eindeutig unterschieden werden.

Während void foo(int) für den Menschen lesbar bleibt, wird sie im maschinennahen Code z. B. zu _Z3fooi. Dieses Verfahren ist notwendig für den Linker, führt aber zu Symbolnamen, die ohne Demangling schwer lesbar sind.

Außer unter MSVC gibt typeid(new_age).name() den vom Compiler gemangelten Type aus: Um trotzdem den menschenlesbaren Typ angezeigt zu bekommen, kann folgenden Hilfsfunktion benutzt werden:

template<typename T>
void output_type(const T& var) 
{ 
    const char* mangled = typeid(var).name(); 
    int status;
    const std::unique_ptr<char, void(*)(void*)> demangled { 
        abi::__cxa_demangle(mangled, nullptr, nullptr, &status), 
        std::free 
    }; 
    if (status == 0 && demangled) 
        std::cout << "Typ: " << demangled.get() << '\n'; 
    std::cout << "Typ (mangled): " << mangled << '\n'; 
}

Schleifen mit auto

Wenn wir beispielsweise über einen Vector iterieren wollen, musste das bis einschließlich C++03 so gemacht werden.

std::vector<int> v = {1, 2, 3}; 
for (std::vector<int>::iterator it = v.begin(); it != v.end(); ++it) 
{
    std::cout << *it << '\n';
}

Seit C++11 kann das auch viel kürzer geschrieben werden:

for (const auto& value : v){
    std::cout << value << '\n';
}

Es empfiehlt sich hier, const auto& zu verwenden, da sonst jedes Element aus dem Vektor kopiert würde.

auto und const

auto entfernt standardmäßig const- und Referenz-Qualifizierer.
Wenn du sie erhalten willst, musst du sie explizit angeben – z. B. const auto&.

Fazit

Das auto Keyword ist eine sehr nützliche Erweiterung in C++11, die den Code kürzer und lesbarer macht.
Für Umsteiger von Sprachen wie Python ist es eine Erleichterung, da sie nicht mehr ständig an die Typen denken müssen.

Das auto keyword – Modernes C++