C++ auto-Schlüsselwort: Typableitung mit Beispielen erklärt

Lass den Compiler den Typ wählen

Auf der vorherigen Seite hast du gesehen, dass jede C++-Variable einen festen Typ hat - int, double, std::string und so weiter. Diesen Typ von Hand auszuschreiben ist bei int count = 0; in Ordnung, wird aber unübersichtlich, sobald die Typen länger werden. Das Schlüsselwort auto (C++11 und später) lässt den Compiler den Typ aus dem zugewiesenen Wert ableiten, sodass du den Wert einmal schreibst und den Rest dem Compiler überlässt.

#include <iostream>
using namespace std;

int main() {
    auto count = 0;        // int
    auto price = 3.99;     // double
    auto letter = 'A';     // char
    auto greeting = "hi";  // const char*

    cout << count << " " << price << " " << letter << " " << greeting << "\n";
    return 0;
}

Die Kernidee: auto ist keine dynamische Typisierung. Jede Variable hat weiterhin einen konkreten Typ, der zur Übersetzungszeit festgelegt wird. auto erspart dir nur, ihn auszuschreiben.

Warum sich auto auszahlt

Bei kurzen, offensichtlichen Typen sind auto count = 0; und int count = 0; gleich gut lesbar. Wo sich auto wirklich auszahlt, sind lange, sich wiederholende Typnamen - die Art, die man von den Containern und Iteratoren der Standardbibliothek bekommt.

Vergleiche die ausführliche Version mit der auto-Version:

// Ohne auto - der Typ wird faktisch zweimal geschrieben
std::vector<std::pair<std::string, int>>::iterator it = scores.begin();

// Mit auto - der Compiler kennt den Typ bereits
auto it = scores.begin();

Beide deklarieren genau denselben Iteratortyp. Die zweite ist leichter zu lesen und gerät nicht aus dem Takt, wenn du scores später in einen anderen Container änderst.

Hier in einem vollständigen Programm:

#include <iostream>
#include <vector>
#include <string>
using namespace std;

int main() {
    vector<pair<string, int>> scores = {{"Ada", 90}, {"Boris", 85}};

    for (auto it = scores.begin(); it != scores.end(); ++it) {
        cout << it->first << ": " << it->second << "\n";
    }
    return 0;
}

auto in bereichsbasierten for-Schleifen

Der häufigste Ort, an dem dir auto begegnet, ist die bereichsbasierte for-Schleife. Du willst den Elementtyp fast nie von Hand ausschreiben, und wie du das auto schreibst, entscheidet, ob du eine Kopie oder eine Referenz bekommst.

#include <iostream>
#include <vector>
#include <string>
using namespace std;

int main() {
    vector<string> names = {"Ada", "Boris", "Rosa"};

    // const auto& - schreibgeschützt, keine Kopie. Der übliche Standard zum Lesen.
    for (const auto& name : names) {
        cout << name << "\n";
    }
    return 0;
}

Drei Varianten, die dir begegnen, und was jede bedeutet:

• for (auto x : v) - x ist eine Kopie jedes Elements. Günstig für int, verschwenderisch für große Objekte.
• for (auto& x : v) - x ist eine Referenz; du kannst die Elemente an Ort und Stelle ändern.
• for (const auto& x : v) - x ist eine schreibgeschützte Referenz. Verwende sie, wenn du nur lesen musst.

Das nächste Programm verändert den Container über auto&:

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> nums = {1, 2, 3};

    for (auto& n : nums) {
        n *= 10;        // ändert das echte Element
    }

    for (const auto& n : nums) {
        cout << n << " ";   // 10 20 30
    }
    cout << "\n";
    return 0;
}

Fallstrick: Schreibst du in dieser Schleife for (auto n : nums) (ohne &), würde n *= 10 stillschweigend nur die Kopie ändern und nums unangetastet lassen. Der Compiler warnt dich nicht - die Schleife tut einfach nichts Nützliches.

Was auto verwirft

Ein einfaches auto leitet den Typ genauso ab wie ein per Wert übergebener Funktionsparameter: Es verwirft das const der obersten Ebene, Referenzen und volatile. Das bedeutet, dass auto dir immer eine frische, veränderbare Kopie liefert, sofern du nichts anderes verlangst.

#include <iostream>
using namespace std;

int main() {
    const int original = 42;

    auto copy = original;   // der Typ ist int, NICHT const int
    copy = 100;             // völlig zulässig - das const wurde verworfen

    cout << original << " " << copy << "\n";  // 42 100
    return 0;
}

Wenn du das const behalten oder die Kopie vermeiden willst, fügst du die Qualifizierer selbst hinzu. Das Muster besteht darin, auto genauso zu schmücken, wie du jeden Typ schmücken würdest:

#include <iostream>
#include <string>
using namespace std;

int main() {
    string name = "Ada";

    const auto& ref = name;   // const std::string& - keine Kopie, schreibgeschützt
    cout << ref << " has " << ref.size() << " letters\n";

    // ref = "Boris";         // Fehler: ref ist const
    return 0;
}

auto leitet also den Basistyp ab; &, const und * sind Stellschrauben, die du obendrauf setzt. auto ist der Typ, const auto& ist eine schreibgeschützte Referenz darauf.

Häufige Fehler und Fallstricke

auto nimmt dir den Tippaufwand ab, nicht die Notwendigkeit, Typen zu verstehen. Ein paar Fallen erwischen Anfänger:

Du musst initialisieren. auto hat aus einer leeren Deklaration nichts abzuleiten, daher ist dies ein harter Übersetzungsfehler:

auto x;        // error: declaration of 'auto x' has no initializer
auto y = 0;    // in Ordnung

Ganzzahlliterale sind int, nicht double. auto half = 1 / 2; leitet int ab und speichert 0, weil 1 / 2 eine Ganzzahldivision ist, bevor auto es überhaupt zu sehen bekommt. Der Typ folgt dem Wert:

#include <iostream>
using namespace std;

int main() {
    auto wrong = 1 / 2;      // Ganzzahldivision -> 0
    auto right = 1.0 / 2;    // double -> 0.5

    cout << wrong << " " << right << "\n";  // 0 0.5
    return 0;
}

auto verwirft die Referenz - achte auf Überraschungen mit hängenden Kopien. Wenn eine Funktion eine Referenz zurückgibt und du sie mit einfachem auto auffängst, bekommst du eine Kopie, was in einer heißen Schleife manchmal ein echter Performance-Bug ist (eine tiefe Kopie eines großen Objekts in jeder Iteration). Greife zu const auto&, wenn du „anschauen, nicht mitnehmen" meinst.

Verstecke den Typ nicht, wenn er wichtig ist. auto result = compute(); ist in Ordnung, wenn der Rückgabetyp von compute aus dem Kontext offensichtlich ist, aber wenn ein Leser erst suchen muss, was result tatsächlich ist, kann das Ausschreiben des Typs die freundlichere Wahl sein. auto dient dazu, Rauschen zu reduzieren, nicht dazu, die Absicht zu verbergen.

Weiter: Konstanten und const

Du hast nun gesehen, dass auto const bewusst verwirft, sofern du nicht darum bittest, es zu behalten - was die naheliegende Frage aufwirft: Was garantiert const eigentlich, und wann solltest du einen Wert überhaupt als unveränderlich markieren? Die nächste Seite gräbt sich in const, konstante Ausdrücke und warum „mach es standardmäßig const" eine der nützlichsten Gewohnheiten in C++ ist.