Wie viel ist zu viel mit C ++ 11 Auto Keyword?

Habe ich mit der neuen auto keyword-erhältlich in den standard C++11 für komplizierte Vorlagen-Arten, die ist, was ich glaube, für die es entworfen wurde. Aber ich bin auch mit es für Dinge wie:

auto foo = std::make_shared<Foo>();

Und mehr skeptisch für:

auto foo = bla(); //where bla() return a shared_ptr<Foo>

Ich habe nicht gesehen, viel Diskussion über dieses Thema. Es scheint, dass auto könnte überstrapaziert werden, da ein Typ ist oft eine form der Dokumentation und Plausibilitätsprüfungen. Wo ziehen Sie die Linie in der Verwendung auto und was sind die empfohlenen Anwendungsfälle für dieses neue feature?

Klarzustellen: ich verlange nicht, für eine philosophische Meinung; ich verlange für die beabsichtigte Verwendung des this-Schlüsselworts, indem Sie das standard-Komitee, ggf. mit Kommentaren, wie, dass die bestimmungsgemäße Verwendung ist in der Praxis realisiert.

Anmerkung: Diese Frage wurde verschoben, um SE.Programmierer und dann zurück zum Stack-Overflow. Diskussion zu diesem Thema finden Sie in diesem meta-Frage.

Kommentar zu dem Problem

Dies ist eine Q&Eine Seite, obwohl sein, nicht eine Diskussion, site. Sie fragte eine sehr sehr Allgemeine Frage, und ich bezweifle, dass jemand werden in der Lage sein, um Ihnen alles andere als eine höchst subjektive. (deswegen die -1) Kommentarautor: TravisG

@heishe, ich habe eine Klarstellung. Wenn Sie Lesen, die Frage ist sehr allgemein, es scheint sich die Frage zu stellen, eine subjektive Meinung, aber wirklich, wenn Sie verwendet die auto - Schlüsselwort, dann wissen Sie wie es ist soll verwendet werden. Das ist, was ich verlange, als jemand, der neu in dieser Funktion ist wie soll ich es verwenden? Kommentarautor: Alan Turing

Ich habe diese Diskussion gesehen, alle über dem Platz, wenn C# eingeführt var (das heißt, sobald die Menschen haben über die Idee, dass es nicht dynamische Eingabe, nachdem alle). Wenn Sie möchten, können Sie beginnen mit diese Frage und gehen Sie durch die Fragen. Kommentarautor: R. Martinho Fernandes

@Lex : Entweder etwas ist rechtliche oder es ist es nicht; der Aufruf etwas "schlechtes", dass legal ist, ist subjektiv durch die definition. I. e., Aufruf von auto foo = bla(); "schlecht" ist eindeutig eine Meinung, nicht eine Tatsache, welche macht dieses Frage-und Antwort-ein Gespräch, das macht es relevant für Programmierer SE, das ist genau das, was schließen Stimmen geben. /shrug Kommentarautor: ildjarn

Herb Sutter Blick auf diese Angelegenheit: herbsutter.com/2013/06/13/... Kommentarautor: rafak

InformationsquelleAutor der Frage Alan Turing | 2011-06-22

auto c++c++11 type-inference types

111

Ich glaube, man sollte die auto Schlüsselwort, wenn es ist schwer zu sagen, wie zu schreiben der Typ auf den ersten Blick, aber der Typ von der rechten Seite eines Ausdrucks ist offensichtlich. Zum Beispiel mit:
```
my_multi_type::nth_index<2>::type::key_type::composite_key_type::\
key_extractor_tuple::tail_type::head_type::result_type
```
um den zusammengesetzten Schlüssel geben boost::multi_index, obwohl Sie wissen, dass es int. Sie können nicht nur schreiben int denn es könnte in Zukunft geändert werden. Ich würde schreiben auto in diesem Fall.

Also, wenn die auto keyword verbessert die Lesbarkeit in einem bestimmten Fall ist, dann verwenden Sie es. Schreiben Sie auto wenn es offensichtlich ist dem Leser, welche Art auto darstellt.

Hier sind einige Beispiele:
```
auto foo = std::make_shared<Foo>(); //obvious
auto foo = bla(); //unclear. don't know which type `foo` has

const size_t max_size = 100;
for ( auto x = max_size; x > 0; --x ) //unclear. could lead to the errors
                                      //since max_size is unsigned

std::vector<some_class> v;
for ( auto it = v.begin(); it != v.end(); ++it ) //ok, since I know
//that `it` has an iterator type (don't really care which one in this context)
```
InformationsquelleAutor der Antwort Kirill V. Lyadvinsky
53

Verwenden auto überall kann man—besonders const auto so, dass die Nebenwirkungen weniger problematisch. Sie müssen nicht sorgen zu machen über die Arten, außer in offensichtlichen Fällen, aber Sie werden immer noch statisch überprüft für Sie, und können Sie vermeiden, einige Wiederholungen. Wo auto ist nicht machbar, können Sie decltype zu äußern Arten semantisch als Verträge auf Ausdrücken basieren. Ihr code wird anders Aussehen, aber es wird eine positive Veränderung.

InformationsquelleAutor der Antwort Jon Purdy
42

Einfach. Verwenden Sie es, wenn Sie egal was der Typ ist. Zum Beispiel
```
for (const auto & i : some_container) {
   ...
```
Alle die mir wichtig hier ist, dass i ist, was in die container.

Es ist ein bisschen wie typedefs.
```
typedef float Height;
typedef double Weight;
//....
Height h;
Weight w;
```
Hier, ist mir egal, ob h und w sind floats oder doubles, nur, dass Sie welcher Art auch immer geeignet ist, um auszudrücken, Höhen und GEWICHTE.

Oder betrachten
```
for (auto i = some_container .begin (); ...
```
Hier alle die mir wichtig ist, dass es einen passenden iterator, unterstützen operator++(), es ist wie eine Art duck typing in dieser Hinsicht.

Auch der Typ von lambdas kann nicht geschrieben werden, so auto f = []... ist guter Stil. Die alternative ist die Umwandlung std::function aber das kommt mit overhead.

Ich kann mir nicht wirklich vorstellen, dass ein "Missbrauch" von auto. Der nächste, den ich mir vorstellen kann ist, berauben Sie sich selbst von eine explizite Konvertierung in einige signifikante geben -- aber Sie würden nicht mit auto für, die, würden Sie konstruieren ein Objekt des gewünschten Typs.

Wenn Sie kann entfernen Sie einige Redundanz im code, ohne dass Nebenwirkungen, dann ist es muss gut zu tun.

Gegenbeispiele (ausgeliehen von jemand anderes Antworten):
```
auto i = SomeClass();
for (auto x = make_unsigned (y); ...)
```
Wir hier TUN, egal, was der Typ, also sollten wir schreiben Someclass i; und for(unsigned x = y;...

InformationsquelleAutor der Antwort spraff
40

Gehen Sie für es. Verwenden auto überall, es macht das schreiben von code einfacher.

Jedem neuen feature, das in jeder Sprache wird überstrapaziert von zumindest einigen Arten von Programmierern. Es ist nur durch moderate überbeanspruchung durch einige erfahrene Programmierer (nicht noobs), dass der rest der erfahrene Programmierer lernen, die Grenzen der ordnungsgemäßen Verwendung. Extreme übernutzung ist in der Regel schlecht, aber könnte gut sein, denn solche überbeanspruchung kann zu Verbesserungen führen, in der Funktion oder eine bessere Funktion zu ersetzen.

Aber wenn ich code arbeiten zu müssen, mit mehr als ein paar Zeilen wie
```
auto foo = bla();
```
wo der Typ angezeigt wird null mal, ich ändern möchten, die Zeilen zu zählen-Typen. Das erste Beispiel ist groß, da der Typ erklärte einmal, und auto spart uns davor zu schreiben, chaotisch und vorgefertigte Typen zweimal. Hurra für C++++. Aber explizit zeigen die Typ null mal, wenn es nicht gut sichtbar in einem nahe gelegenen Zeile, der mich nervös macht, zumindest in C++ und seiner unmittelbaren Nachfolger. Für andere Sprachen entwickelt, um die Arbeit auf einem höheren Niveau mit mehr Abstraktion, Polymorphismus und genericity, es ist in Ordnung.

InformationsquelleAutor der Antwort DarenW
35

Ja, es kann sein, überstrapaziert zu Lasten der Lesbarkeit. Ich schlage vor, die Verwendung in den Kontexten, in denen die genauen Arten sind lange, oder unsagbaren, oder nicht wichtig für die Lesbarkeit, und Variablen sind nur von kurzer Dauer. Zum Beispiel iterator-Typ in der Regel ist lang und nicht wichtig ist, so auto funktionieren würde:
```
   for(auto i = container.begin(); i != container.end(); ++i);
```
auto hier nicht verletzt Lesbarkeit.

Ein weiteres Beispiel ist die parser-Regel type, der sein kann lange und komplizierte. Vergleichen:
```
   auto spaces = space & space & space;
```
mit
```
r_and_t<r_and_t<r_char_t<char>&, r_char_t<char>&>, r_char_t<char>&> spaces = 
   space & space & space;
```
Auf der anderen Seite, wenn die Art bekannt ist und ist einfach, es ist viel besser, wenn es ausdrücklich:
```
int i = foo();
```
eher als
```
auto i = foo();
```
InformationsquelleAutor der Antwort Gene Bushuyev
30

In C++ and Beyond 2012 in der Fragen Sie Uns Alles, was - panel, es war ein fantastischen Austausch zwischen Andrei Alexandrescu, Scott Meyers und Herb Sutter reden, wenn zu bedienen und nicht mit auto. Springen Sie zu minute 25:03 für ein 4-minütigen Diskussion. Alle drei Referenten geben ausgezeichnete Punkte, die im Auge behalten werden sollte, wenn zu nicht verwenden auto.

Ich sehr, Menschen zu ermutigen, zu seiner eigenen Entscheidung kommen, aber meine nehmen war verwenden auto überall , es sei denn:
1. Es tut weh Lesbarkeit
2. Gibt es Besorgnis über eine automatische Typkonvertierung (z.B. von Konstruktoren, Zuweisung, Vorlage intermediate types, implizite Konvertierung zwischen integer-breiten)
Liberale Verwendung von explicit hilft verringern die Sorge für die letzteren, die hilft, den Zeitraum zu minimieren, der ehemalige ist ein Problem.

Umformulieren, was Herb sagt, "wenn Sie nicht tun, X, Y und Z verwenden auto. Erfahren Sie, was X, Y und Z sind und gehen Sie her und verwenden Sie auto überall sonst."

InformationsquelleAutor der Antwort Sean
15

auto kann sehr gefährlich in Kombination mit expression templates, die verwendet werden, eine Menge, die durch lineare-algebra-Bibliotheken, wie zum Beispiel Eigen-oder OpenCV.
```
auto A = Matrix(...);
auto B = Matrix(...);
auto C = A * B; //C is not a matrix. It is a matrix EXPRESSION.
cout << C; //The expression is evaluated and gives the expected result.
... //<code modifying A or B>
cout << C; //The expression is evaluated AGAIN and gives a DIFFERENT result.
```
Bugs, verursacht durch diese Art von Fehler sind ein großer Schmerz, zu Debuggen. Eine mögliche Abhilfe ist der explizite cast das Ergebnis mit dem erwarteten Typ, wenn Sie sind versessen darauf mit auto für die Links-rechts-Erklärung-Stil.
```
auto C = Matrix(A * B); //The expression is now evaluated immediately.
```
InformationsquelleAutor der Antwort morotspaj
8

Benutze ich auto ohne Einschränkung, und nicht vor einem problem. Ich habe sogar manchmal das es für einfache Typen wie int. Dies macht c++ zu einer Sprache auf höherer Ebene für mich, und erlaubt das deklarieren von Variablen in c++ wie in python. Nach dem schreiben von python-code habe ich auch manchmal schreiben Sie z.B.
```
auto i = MyClass();
```
statt
```
MyClass i;
```
Dies ist ein Fall, wo ich sagen würde es ist ein Missbrauch der auto Stichwort.

Oft ich bin nicht dagegen, was ist der genaue Typ des Objekts, ich bin mehr daran interessiert, seine fonctionality, und als Funktion der Namen in der Regel sagen etwas über die Objekte, die Sie zurückgeben, auto verletzt: z.B. auto s = mycollection.size(), ich kann mir vorstellen, dass s wird eine Art integer, und in dem seltenen Fall, wo ich die Sorge um die genaue Art, let ' s check-Funktion Prototyp dann (ich meine, ich bevorzuge es, zu überprüfen, Wann brauche ich die info, anstatt a priori, wenn code geschrieben wird, nur für den Fall, es wäre nützlich, eines Tages, als in int_type s = mycollection.size()).

Bezug auf dieses Beispiel aus der akzeptierten Antwort:
```
for ( auto x = max_size; x > 0; --x )
```
In meinem code benutze ich immer noch auto in diesem Fall, und wenn ich will x werden, unsigniert, dann benutze ich eine utility-Funktion, namens sagen make_unsigned, die drückt deutlich meine Bedenken:
```
for ( auto x = make_unsigned(max_size); x > 0; --x )
```
disclaimer: ich habe nur beschreiben meine verwenden, bin ich nicht kompetent Ratschläge geben!

InformationsquelleAutor der Antwort rafak
2

Einer Gefahr habe ich festgestellt, ist in Bezug auf Referenzen.
z.B.
```
MyBigObject& ref_to_big_object= big_object;
auto another_ref = ref_to_big_object; //?
```
Das problem ist another_ref ist nicht wirklich eine Referenz in diesem Fall ist es MyBigObject statt MyBigObject&. Sie am Ende kopieren ein großes Objekt, ohne es zu merken.

Wenn Sie eine Referenz direkt aus einer Methode, die Sie vielleicht nicht darüber nachzudenken, was es eigentlich ist.
```
auto another_ref = function_returning_ref_to_big_object();
```
müssten Sie "auto - &" oder "const auto&"
```
MyBigObject& ref_to_big_object= big_object;
auto& another_ref = ref_to_big_object;
const auto& yet_another_ref = function_returning_ref_to_big_object();
```
InformationsquelleAutor der Antwort user2495422
2

Einer der großen problem mit C++ Programm ermöglicht es Ihnen, die nicht initialisierte variable. Dies führt uns zu der böse nicht-deterministische Verhalten des Programms. Es sollte angemerkt werden, dass moderne compiler jetzt werfen geeignet/Meldung Warnmeldungen, wenn das Programm Reifen zu verwenden.

Nur um dies zu veranschaulichen, betrachten Sie unter c++ - Programm:
```
int main() {
    int x;
    int y = 0;
    y += x;
}
```
Wenn ich kompilieren Sie dieses Programm mit modernen compiler(GCC), gibt es die Warnung. Eine solche Warnung kann nicht sein
sehr offensichtlich sind, wenn wir arbeiten mit den realen komplexen Produktions-code.
main.cpp: In function 'int main()':

main.cpp:4:8: Warnung: 'x' verwendet wird, nicht initialisiert in dieser Funktion
[-Wuninitialized]

y += x;
```
    ^
```
=================================================================================
Nun, wenn wir ändern unser Programm, das verwendet auto, dann kompilieren, erhalten wir die folgende:
```
int main() {
    auto x;
    auto y = 0;
    y += x;
}
```
main.cpp: In function 'int main()':

main.cpp:2:10: Fehler: Erklärung von "auto-x" hat keine Initialisierer
```
 auto x;

      ^
```
Mit auto, es ist nicht möglich, mit dem uninitialisierte variable. Dies ist ein wesentlicher Vorteil den wir bekommen können(für frei), wenn wir anfangen, mit auto.

Diesem Konzept und anderen großen große moderne C++ - Konzept erklärt sich durch C++ - Experte Kraut Shutter in seinem CppCon14 sprechen:

Zurück zu den Grundlagen! Grundlagen der Modernen C++ - Stil

InformationsquelleAutor der Antwort Mantosh Kumar
1

Verwenden auto wo es Sinn macht, für eine Art hergeleitet werden. Wenn Sie etwas haben, das Sie wissen, ist ein integer, oder Sie wissen, es ist eine Zeichenfolge, die nur mit int /std::string, etc. Ich würde nicht sorgen über die "übernutzung" eine Sprache verfügen, es sei denn, es kommt der Punkt der Lächerlichkeit, oder verbirgt code.

Das ist meiner Meinung nach sowieso.

InformationsquelleAutor der Antwort LainIwakura
1

auto Schlüsselwort kann nur verwendet werden, für die lokale variable, nicht auf Argumente oder eine Klasse/Struktur Mitglieder. Also, es ist sicher und sinnvoll verwenden Sie Sie überall Sie mögen. Ich verwenden Sie eine Menge. Der Typ ableiten, die zur compile-Zeit, der debugger zeigt den Typ beim Debuggen, die sizeof richtig meldet, die decltype geben würde, die richtige Art - gibt es keinen Schaden. Ich zähle nicht auto als überstrapaziert, nie!

InformationsquelleAutor der Antwort Ajay
1

TL;DR: Siehe Regel-of-Daumen an der Unterseite.

Den akzeptierte Antwort schlägt folgende Faustregel:

Verwenden auto wenn es schwer zu sagen, wie zu schreiben der Typ auf den ersten Blick, aber der Typ von der rechten Seite eines Ausdrucks ist offensichtlich.

Aber ich würde sagen, das ist zu restriktiv. Irgendwann habe ich kümmern sich nicht um die Typen, denn die Aussage ist informativ genug, ohne mir die Mühe zu machen die Zeit nehmen, die Abbildung der type aus. Was mache ich damit? Betrachten Sie das Beispiel, das tauchte in einigen der Antworten:
```
auto x = f();
```
Macht dies ein Beispiel für den Missbrauch von auto? Ist es meine Unkenntnis der f()'s zurück geben? Gut, es kann ja helfen, wenn ich wüsste es, aber das ist nicht mein Hauptanliegen. Was ist viel mehr ein problem ist, dass x und f() sind ziemlich bedeutungslos. Wenn wir hatten:
```
auto nugget = mine_gold();
```
anstelle, dann habe ich in der Regel don ' T care, ob der Rückgabetyp der Funktion offensichtlich ist oder nicht. Das Lesen der Anweisung, ich weiß, was ich Tue und ich weiß genug über das, was der Rückgabewert ist die Semantik nicht das Gefühl, ich muss auch wissen, dass seine Art.

Also meine Antwort ist: Verwenden Sie auto wenn der compiler es zulässt, es sei denn:
- Fühlen Sie den Namen der Variablen zusammen mit der Initialisierung /assignment expression liefern nicht genügend Informationen darüber, was die Anweisung macht.
- Fühlen Sie den Namen der Variablen zusammen mit der Initialisierung /assignment expression "irreführende" Informationen über das, was der Typ sein soll - also, wenn Sie zu erraten, was kommt statt dem auto würde Sie in der Lage sein, um eine Vermutung - und es wäre falsch, und diese falsche Annahme hat Auswirkungen später im code.
- Sie zwingen wollen, einen anderen Typ (z.B. ein Verweis).
Und auch:
- Bevorzugen, geben Sie einen aussagekräftigen Namen (die nicht enthalten ist der name natürlich), bevor Sie auto mit den konkreten Typ.
InformationsquelleAutor der Antwort einpoklum
-3

Einer meiner bitteren Erfahrung mit auto ist verwenden Sie es mit lambda-Ausdrücken:
```
auto i = []() { return 0; };
cout<<"i = "<<i<<endl; //output: 1 !!!
```
Eigentlich hier i aufgelöst Funktion Zeiger der int(*)(). Dies ist nur eine einfache cout, aber Stell dir vor, welche Art von bad compilation /runtime-Fehlern es führen kann, wenn verwendet mit template.

Sollten Sie vermeiden auto mit solchen Ausdrücken und setzen eine ordnungsgemäße return Typ (oder kontrolliert decltype())

Richtige Verwendung für das obige Beispiel wäre,
```
auto i = []() { return 0; }(); //and now i contains the result of calling the lambda  
```
InformationsquelleAutor der Antwort iammilind

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.