Soll ich die neue C ++ 11-Funktion "Auto" verwenden, insbesondere in Schleifen?

Was sind die Vor- / Nachteile der auto Schlüsselworts, insbesondere bei for-Schleifen?

for(std::vector<T>::iterator it = x.begin(); it != x.end(); it++ )
{
   it->something();
}

for(std::map<T>::iterator it = x.begin(); it != x.end(); it++ )
{
   it->second->something();
}

for(auto it = x.begin(); it != x.end(); it++ )
{
   it->??
}

Wenn Sie nicht wissen, ob Sie einen Iterator für eine Karte oder einen Vektor haben, würden Sie wahrscheinlich nicht wissen, ob Sie ihn verwenden sollen firstsecond Eigenschaften des Objekts oder direkt darauf zugreifen sollen, nein?

Dies erinnert mich an die C # -Debatte über die Verwendung des Schlüsselworts var. Der Eindruck, den ich bisher habe, ist, dass die Leute in der C ++ - Welt bereit sind, das autoSchlüsselwort mit weniger Kampf als varin der C # -Welt zu übernehmen. Für mich ist mein erster Instinkt, dass ich gerne den Typ der Variablen kenne, damit ich weiß, welche Operationen ich erwarten kann, um sie auszuführen.

Die Motivationen in C ++ sind extremer, da Typen aufgrund von Metaprogrammierung und anderen Dingen sehr viel komplexer und komplexer werden können als C # -Typen. autoist schneller zu schreiben und zu lesen und flexibler / wartbarer als ein expliziter Typ. Ich meine, möchtest du anfangen zu tippen?

boost::multi_map<NodeType, indexed_by<ordered_unique<identity<NodeType>>, hashed_non_unique<identity<NodeType>, custom_hasher>>::iterator_type<0> it

Das ist nicht mal der volle Typ. Ich habe ein paar Template-Argumente verpasst.

In deinem Beispiel:

for(auto it = x.begin(); it != x.end(); i++)
{
  it->??
}

es muss eine deklaration für xsichtbar geben. Daher sollte die Art der itoffensichtlich sein. Wenn der Typ xnicht offensichtlich ist, ist die Methode zu lang oder die Klasse zu groß.

Einspruch ! Geladene Frage.

Können Sie mir erklären, warum der dritte Code enthalten ist ??, der erste und der zweite jedoch nicht? Der Fairness halber, Ihr Code muss lesen folgt als:

for(std::vector<T>::iterator it = x.begin(); it != x.end(); i++)
{
   it->???
}

for(std::map<T>::iterator it = x.begin(); it != x.end(); i++)
{
   it->second->???
}

Dort. Das gleiche Problem, obwohl Sie es nicht benutzt haben auto.

In allen Fällen ist die Antwort dieselbe: Der Kontext ist wichtig . Sie können nicht sinnvoll isoliert über ein Stück Code sprechen. Selbst wenn Sie keine Vorlagen, sondern einen konkreten Typ verwendet hätten, hätte dies das Problem nur an eine andere Stelle verschoben, da der Leser Ihres Codes über die Deklaration dieses Typs Bescheid wissen müsste.

Bei Verwendung von auto in diesen Situationen Ihren Code unleserlich macht, sollten Sie dies als Warnzeichen dafür behandeln, dass etwas mit Ihrem Code-Design nicht stimmt. Natürlich gibt es Fälle, in denen Details auf niedriger Ebene von Bedeutung sind (z. B. bei Bitoperationen oder älteren APIs). In diesen Fällen kann ein expliziter Typ die Lesbarkeit verbessern. Aber im Allgemeinen - nein.

In Bezug auf var(da Sie es ausdrücklich erwähnt haben), gibt es auch einen großen Konsens in der C # -Community für die Verwendung var. Argumente gegen seine Verwendung beruhen im Allgemeinen auf Irrtümern .

PROFI

Dein Code :

for(std::vector<T>::iterator it = x.begin(); it != x.end(); i++)

wird wegen des vorlagenabhängigen Namens nicht kompiliert.

Dies ist die korrekte Syntax:

for( typename std::vector<T>::iterator it = x.begin(); it != x.end(); i++)

Nun schauen Sie, wie lang die Typdeklaration ist. Hier erfahren Sie, warum das autoSchlüsselwort eingeführt wurde. Dies :

for( auto it = x.begin(); it != x.end(); i++)

ist prägnanter. Das ist also ein Profi.

CON

Du musst ein bisschen vorsichtig sein. Mit dem Schlüsselwort erhalten autoSie den Typ, den Sie deklariert haben.

Beispielsweise :

std::vector< int > v{ 1, 2, 3, 4 };
for ( auto it : v )
{
  ++ it;   // ops modifying copies of vector's elements
}

vs

std::vector< int > v{ 1, 2, 3, 4 };
for ( auto & it : v )   // mind the reference
{
  ++ it;   // ok, vector's elements modified
}

Zum Schluss: Ja, Sie sollten es, aber nicht überbeanspruchen. Einige Leute neigen dazu, es zu oft zu benutzen und setzen auto überall ein, wie im nächsten Beispiel:

auto i = 0;

vs

int i = 0;

Ja du solltest! autolöscht den Typ nicht; Auch wenn Sie nicht wissen, was x.begin()ist, weiß der Compiler Bescheid und meldet einen Fehler, wenn Sie versuchen, den Typ falsch zu verwenden. Es ist auch nicht ungewöhnlich, mapmit a zu emulieren vector<pair<Key,Value>>, sodass der verwendete Code autofür beide Wörterbuchdarstellungen funktioniert.

Ja, Sie sollten autoals Standardregel verwenden. Es hat Vorteile gegenüber der expliziten Angabe des Typs:

• Sie müssen keine Dinge eingeben, die dem Compiler bereits bekannt sind.
• Der Variablentyp "folgt" jeder Änderung der Rückgabewerttypen.
• Auf diese Weise wird die unbeaufsichtigte Einführung impliziter Konvertierungen und das Slicing bei der Initialisierung lokaler Variablen verhindert.
• Einige explizite Typberechnungen in Vorlagen sind nicht mehr erforderlich.
• Die Benennung von Rückgabetypen mit langen Namen entfällt. (diejenigen, die Sie aus der Compiler-Diagnose kopieren und einfügen)

Hier haben Sie die Wahl. Es gibt auch Fälle, in denen Sie keine Wahl haben:

• Es erlaubt die Deklaration von Variablen von nicht sprechbaren Typen, wie dem Typ eines Lambdas.

Vorausgesetzt, Sie wissen genau, was Sie autotun, hat es keine Nachteile.