Das auto-Schlüsselwort in C++ für die Typinferenz

1. das Schlüsselwort auto in C++
2. Verwendung von auto mit Funktionen in C++
3. Verwendung von auto mit Variablen in C++
4. Verwendung von auto mit Iteratoren in C++
5. Verwendung von auto mit Funktionsparametern in C++
6. Fehler bei der Verwendung des Schlüsselworts auto in C++
7. Fazit

Dieses Tutorial befasst sich mit dem in C++ 11 eingeführten Schlüsselwort auto. Wir werden uns verschiedene Beispiele ansehen, um seine Anwendungsfälle und häufige Fehler bei der Verwendung zu verstehen.

das Schlüsselwort auto in C++

Das Schlüsselwort auto in der C++ 11-Version ist Teil der Funktion Type inference. Typrückschluss bedeutet, den Datentyp einer Funktion oder einer Variablen zur Kompilierzeit abzuleiten.

Wir müssen also den Datentyp nicht angeben, den der Compiler zur Kompilierzeit automatisch ableiten kann. Die return-Anweisung hilft uns, den Rückgabedatentyp für die Funktionen abzuleiten.

Bei Variablen hingegen hilft die Initialisierung, den Datentyp zu bestimmen.

Verwendung von auto mit Funktionen in C++

#include <iostream>
using namespace std;

auto division() {
  double a = 55.0;
  double b = 6.0;
  double ans = a / b;
  return ans;
}

int main() { cout << division(); }

Ausgabe:

9.16667

Hier hilft die return-Anweisung dem Compiler, den Rückgabetyp unserer division()-Funktion abzuleiten. Da die Funktion ans zurückgibt, einen Double-Typ, folgert der Compiler, dass auto durch ein Double ersetzt werden muss.

Verwendung von auto mit Variablen in C++

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

int main() {
  auto x = 10;
  auto y = 10.4;
  auto z = "iron man";

  cout << x << endl;
  cout << y << endl;
  cout << z << endl;
}

Ausgabe:

10
10.4
iron man

Anhand der rechten Seite der Anweisung, auch Initializer genannt, leitet der Compiler den Typ der Variablen ab.

Verwendung von auto mit Iteratoren in C++

Beim Umgang mit STL-Containern wie vector, set oder map wird häufig das Schlüsselwort auto verwendet, um über sie zu iterieren. Wir können den Zeitverlust minimieren, indem wir die langwierige Deklaration des Iterators überspringen.

#include <bits/stdc++.h>
using namespace std;

int main() {
  vector<int> v{22, 14, 15, 16};

  vector<int>::iterator it = v.begin();  // without auto
  auto it2 = v.begin();

  while (it2 != v.end()) {
    cout << *it2 << " ";
    it2++;
  }
  cout << endl;

  map<int, int> mp;
  mp.insert(pair<int, int>(1, 40));
  mp.insert(pair<int, int>(2, 30));
  mp.insert(pair<int, int>(3, 60));
  mp.insert(pair<int, int>(4, 20));

  map<int, int>::iterator vt = mp.begin();  // without auto
  auto vt2 = mp.begin();

  while (vt2 != mp.end()) {
    cout << vt2->first << " -> " << vt2->second << endl;
    vt2++;
  }
  cout << endl;
}

Ausgabe:

22 14 15 16
1 -> 40
2 -> 30
3 -> 60
4 -> 20

Wir beobachten den Unterschied zwischen der Verwendung von auto und nicht. Ohne auto müssen wir den Typ des Iterators explizit angeben, was mühsam ist, da die Anweisungen ziemlich lang sind.

Verwendung von auto mit Funktionsparametern in C++

In C++ müssen wir die Funktionsparameter jedes Mal angeben, aber das kann durch die Verwendung von auto vereinfacht werden.

#include <bits/stdc++.h>
using namespace std;

void myfunc(auto x, auto str) { cout << x << " " << str << endl; }

int main() {
  int x = 10;
  string str = "Iron Man";
  myfunc(x, str);
}

Ausgabe:

10 Iron Man

Die Ableitung von Datentypen geschieht während des Funktionsaufrufs. Folglich erfolgt der Abgleich von Variablen, und der Compiler ermittelt die genauen Datentypen für alle Argumente.

Fehler bei der Verwendung des Schlüsselworts auto in C++

Integer vs. Boolesche Verwirrung

In C++ wissen wir, dass boolesche Werte als 0 oder 1 initialisiert werden. Dies könnte beim Debuggen zu Verwirrung führen.

#include <bits/stdc++.h>
using namespace std;

int main() { auto temp = 0; }

Mehrere Deklarationen mit dem Schlüsselwort auto

Wir deklarieren Variablen auf einmal, um Zeit zu sparen, aber das kann zu Problemen führen, wenn beide unterschiedliche Typen haben.

#include <bits/stdc++.h>
using namespace std;

int main() { auto x = 10, y = 35.66; }

Ausgabe:

[Error] inconsistent deduction for 'auto': 'int' and then 'double'

Wenn wir den obigen Code in einem Compiler kompilieren, erhalten wir einen Fehler, und dies geschieht, weil der Compiler verwirrt wird.

Fazit

Wir haben verstanden, dass das Schlüsselwort auto viel Zeit beim Schreiben eines einfachen Codes spart und sich auf die intensiveren und komplexeren Teile eines Programms konzentriert. Obwohl es sehr nützlich ist, müssen wir vorsichtig sein, wie wir es verwenden.