auto-Schlüsselwort (Typableitung)

Leitet den Typ einer deklarierten Variable vom entsprechenden Initialisierungsausdruck ab.

auto declarator initializer;

Hinweise

Das auto-Schlüsselwort weist den Compiler an, den Initialisierungsausdruck einer deklarierten Variable zu verwenden, um den Typ herzuleiten.

Es wird empfohlen, in den meisten Fällen das auto-Schlüsselwort zu verwenden (es sei denn, Sie möchten wirklich eine Konvertierung durchführen), denn diese Vorgehensweise bietet folgende Vorteile:

• Stabilität: Wenn der Typ des Ausdrucks geändert wird (dies schließt auch die Änderung eines Funktionsrückgabetyps ein), funktioniert der Vorgang weiterhin.

• Leistung: Sie haben die Sicherheit, dass keine Konvertierung durchgeführt wird.

• Benutzerfreundlichkeit: Sie müssen sich keine Gedanken um Schwierigkeiten und Fehler bei der Schreibweise der Typnamen machen.

• Effizienz: Ihre Codierung kann effizienter sein.

Fälle von Konvertierungen, bei denen Sie auto möglicherweise nicht verwenden sollten:

• Wenn Sie einen ganz bestimmten Typ benötigen, und nichts anderes infrage kommt.

• Hilfetypen für Ausdrucksvorlagen, beispielsweise (valarray+valarray) und Initialisiererlisten (obwohl Sie in seltenen Fällen auto x = { 1 }; schreiben und erwarten können, dass int zurückgegeben wird).

Wenn Sie das auto-Schlüsselwort verwenden, verwenden Sie es anstelle eines Typs, um eine Variable zu deklarieren, und geben Sie einen Initialisierungsausdruck an. Darüber hinaus können Sie das auto-Schlüsselwort mithilfe von Bezeichnern und Deklaratoren wie const, volatile, Zeigern (*), Verweisen (&) und rvalue-Verweisen ((&&) ändern. Der Compiler wertet den Initialisierungsausdruck aus und verwendet dann diese Informationen, um den Typ der Variable herzuleiten.

Der Initialisierungsausdruck kann eine Zuweisung (Gleichheitszeichensyntax), eine direkte Initialisierung (Funktionsformatsyntax), ein operator new-Ausdruck oder der for-range-declaration-Parameter in einer Bereichsbasiert für Anweisung (C++)-Anweisung sein. Weitere Informationen finden Sie unter Initialisierer und in den Codebeispielen, die später in diesem Dokument aufgeführt sind.

Das auto-Schlüsselwort ist ein Platzhalter für einen Typ, ist jedoch selbst kein Typ. Daher kann das auto-Schlüsselwort nicht in Umwandlungen und Operatoren wie sizeof und typeid (Komponentenerweiterungen für C++) verwendet werden.

Nützlichkeit

Das auto-Schlüsselwort ist eine einfache Möglichkeit, eine Variable zu deklarieren, die einen komplizierten Typ aufweist. Sie können beispielsweise auto verwenden, um eine Variable zu deklarieren, in der der Initialisierungsausdruck Vorlagen, Zeiger auf Funktionen oder Zeiger auf Member umfasst.

Sie können auto außerdem verwenden, um eine Variable zu deklarieren und auf einen Lambda-Ausdruck zu initialisieren. Sie können den Typ der Variable nicht selbst deklarieren, da der Typ eines Lambda-Ausdrucks nur dem Compiler bekannt ist. Weitere Informationen finden Sie unter Beispiele für Lambda-Ausdrücke.

Nachstehende Rückgabetypen

Sie können auto zusammen mit dem decltype-Typspezifizierer verwenden, um Vorlagenbibliotheken zu schreiben. Verwenden Sie auto und decltype, um eine Vorlagenfunktion zu deklarieren, deren Rückgabetyp von den Typen seiner Vorlagenargumente abhängt. Oder verwenden Sie auto und decltype, um eine Vorlagenfunktion zu deklarieren, die einen Aufruf einer anderen Funktion umschließt und anschließend das zurückgibt, was der Rückgabetyp dieser anderen Funktion ist. Weitere Informationen finden Sie unter decltype-Typspezifizierer.

Verweise und CV-Qualifizierer

Beachten Sie, dass durch die Verwendung von auto Verweise, const-Qualifizierer und flüchtige Qualifizierer abgelegt werden. Betrachten Sie das folgende Beispiel:

// cl.exe /analyze /EHsc /W4
#include <iostream>
 
using namespace std;
 
int main( )
{
    int count = 10;
    int& countRef = count;
    auto myAuto = countRef;
 
    countRef = 11;
    cout << count << " ";
 
    myAuto = 12;
    cout << count << endl;
}

Es scheint, als wäre myAuto ein int-Verweis, was jedoch nicht der Fall ist. Es ist einfach ein "int", sodass die Ausgabe 11 11 ist und nicht 11 12, was der Fall wäre, wenn der Verweis nicht von auto abgelegt worden wäre.

Beschränkungen und Fehlermeldungen

Die folgende Tabelle zeigt die Einschränkungen bei der Nutzung des auto-Schlüsselworts und die entsprechende Diagnosefehlermeldung, die der Compiler ausgibt.

Beispiele

Die Codefragmente veranschaulichen einige Verwendungsmöglichkeiten des auto-Schlüsselworts.

Die folgenden Deklarationen sind gleichwertig. In der ersten Anweisung wird die j-Variable als Typ int deklariert. In der zweiten Anweisung wird die k-Variable hergeleitet, um Typ int zu entsprechen, da der Initialisierungsausdruck (0) eine ganze Zahl ist.

   int j = 0;  // Variable j is explicitly type int.
   auto k = 0; // Variable k is implicitly type int because 0 is an integer.

Die folgenden Deklarationen sind gleichwertig, die zweite Deklaration ist jedoch einfacher als die erste. Einer der überzeugendsten Gründe für die Verwendung des auto-Schlüsselworts ist die Einfachheit.

   map<int,list<string>>::iterator i = m.begin(); 
   auto i = m.begin(); 

Das folgende Codefragment deklariert den Typ der Variablen iter und elem, wenn die Schleifen for und range-for beginnen.

// cl /EHsc /nologo /W4
#include <deque>
using namespace std;

int main()
{
    deque<double> dqDoubleData(10, 0.1);

    for (auto iter = dqDoubleData.begin(); iter != dqDoubleData.end(); ++iter)
    { /* ... */ }

    // prefer range-for loops with the following information in mind
    // (this applies to any range-for with auto, not just deque)

    for (auto elem : dqDoubleData) // COPIES elements, not much better than the previous examples
    { /* ... */ }

    for (auto& elem : dqDoubleData) // observes and/or modifies elements IN-PLACE
    { /* ... */ }

    for (const auto& elem : dqDoubleData) // observes elements IN-PLACE
    { /* ... */ }
}

Das folgende Codefragment verwendet den Operator und die Zeigerdeklaration new, um Zeiger zu deklarieren.

   double x = 12.34;
   auto *y = new auto(x), **z = new auto(&x);

Im folgenden Codefragment werden mehrere Symbole in jeder Deklarationsanweisung deklariert. Beachten Sie, dass alle Symbole in jeder Anweisung in den gleichen Typ aufgelöst werden.

   auto x = 1, *y = &x, **z = &y; // Resolves to int.
   auto a(2.01), *b (&a);         // Resolves to double.
   auto c = 'a', *d(&c);          // Resolves to char.
   auto m = 1, &n = m;            // Resolves to int.

Dieses Codefragment verwendet den bedingten Operator (?:), um die x-Variable als ganze Zahl mit einem Wert von 200 zu deklarieren:

   int v1 = 100, v2 = 200;
   auto x = v1 > v2 ? v1 : v2;

Das folgende Codefragment initialisiert die x-Variable mit dem Typ int, die y-Variable mit einem Verweis auf Typ const int und die fp-Variable mit einem Zeiger auf eine Funktion, die den Typ int zurückgibt.

int f(int x) { return x; }
int main()
{
    auto x = f(0);
    const auto & y = f(1);
    int (*p)(int x);
    p = f;
    auto fp = p;
    //...
}

Siehe auch

Referenz

Auto-Schlüsselwort

Speicherklassenspezifizierer

C++-Schlüsselwörter

/Zc:auto (Variablentyp ableiten)

sizeof-Operator

typeid (Komponentenerweiterungen für C++)

operator new (<new>)

Deklarationen

Beispiele für Lambda-Ausdrücke

Initialisierer

decltype-Typspezifizierer