Wie viel ist zu viel mit dem automatischen Schlüsselwort C ++ 11?

Ich habe das neue autoSchlüsselwort verwendet, das im C ++ 11-Standard für komplizierte Vorlagen verfügbar ist. Ich glaube, es wurde dafür entwickelt. Aber ich benutze es auch für Dinge wie:

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

Und skeptischer für:

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

Ich habe nicht viel Diskussion zu diesem Thema gesehen. Es scheint, dass autodies überbeansprucht werden könnte, da ein Typ häufig eine Form der Dokumentation und Überprüfung der geistigen Gesundheit ist. Wo ziehen Sie die Grenze bei der Verwendung autound was sind die empfohlenen Anwendungsfälle für diese neue Funktion?

Zur Verdeutlichung: Ich bitte nicht um eine philosophische Meinung; Ich bitte das Standardkomitee um die beabsichtigte Verwendung dieses Schlüsselworts, möglicherweise mit Kommentaren dazu, wie diese beabsichtigte Verwendung in der Praxis umgesetzt wird.

Randnotiz: Diese Frage wurde zu SE.Programmers und dann zurück zu Stack Overflow verschoben. Eine Diskussion darüber finden Sie in dieser Meta-Frage .

Ich denke, dass man das autoSchlüsselwort immer dann verwenden sollte, wenn es schwierig ist zu sagen, wie man den Typ auf den ersten Blick schreibt, aber der Typ 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üsseltyp einzugeben boost::multi_index, obwohl Sie wissen, dass dies der Fall ist int. Sie können nicht einfach schreiben, intweil es in Zukunft geändert werden könnte. Ich würde autoin diesem Fall schreiben .

Wenn das autoSchlüsselwort in einem bestimmten Fall die Lesbarkeit verbessert, verwenden Sie es. Sie können schreiben, autowenn dem Leser klar ist, welchen Typ er autodarstellt.

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)

Verwenden autoSie es überall, wo Sie können - insbesondere, const autodamit Nebenwirkungen weniger bedenklich sind. Sie müssen sich nur in den offensichtlichen Fällen um Typen kümmern, diese werden jedoch für Sie statisch überprüft, und Sie können Wiederholungen vermeiden. Wo dies autonicht möglich ist, können Sie decltypeTypen semantisch als Verträge ausdrücken, die auf Ausdrücken basieren. Ihr Code wird anders aussehen, aber es wird eine positive Änderung sein.

Einfach. Verwenden Sie es, wenn es Ihnen egal ist, um welchen Typ es sich handelt. Beispielsweise

for (const auto & i : some_container) {
   ...

Alles, was mich hier interessiert, ist, dass ialles in dem Container ist.

Es ist ein bisschen wie typedefs.

typedef float Height;
typedef double Weight;
//....
Height h;
Weight w;

Hier ist es mir egal, ob hund ob wes sich um Schwimmer oder Doppel handelt, nur dass sie für jeden Typ geeignet sind, um Höhen und Gewichte auszudrücken .

Oder überlegen Sie

for (auto i = some_container .begin (); ...

Hier ist mir nur wichtig, dass es ein geeigneter Iterator ist, der unterstützt operator++(), es ist in dieser Hinsicht wie das Tippen von Enten.

Auch die Art der Lambdas kann nicht geschrieben werden, also auto f = []...ist es ein guter Stil. Die Alternative ist Casting, std::functionaber das bringt Overhead mit sich.

Ich kann mir einen "Missbrauch" von nicht wirklich vorstellen auto. Das nächste, was ich mir vorstellen kann, ist, sich einer expliziten Konvertierung in einen signifikanten Typ zu berauben - aber Sie würden das nicht verwenden auto, Sie würden ein Objekt des gewünschten Typs konstruieren.

Wenn Sie Redundanz in Ihrem Code entfernen können , ohne Nebenwirkungen einzuführen, muss dies sinnvoll sein.

Gegenbeispiele (aus den Antworten eines anderen entlehnt):

auto i = SomeClass();
for (auto x = make_unsigned (y); ...)

Hier ist es uns egal, was der Typ ist, also sollten wir schreiben Someclass i;undfor(unsigned x = y;...

Tue es. Verwenden Sie es autoüberall dort, wo es das Schreiben von Code erleichtert.

Jede neue Funktion in einer beliebigen Sprache wird zumindest von einigen Programmierertypen überbeansprucht. Nur durch mäßige Überbeanspruchung durch einige erfahrene Programmierer (nicht durch Noobs) lernt der Rest der erfahrenen Programmierer die Grenzen der richtigen Verwendung. Extreme Überbeanspruchung ist normalerweise schlecht, kann aber gut sein, da eine solche Überbeanspruchung zu Verbesserungen der Funktion oder zu einer besseren Funktion führen kann, um sie zu ersetzen.

Aber wenn ich an Code mit mehr als ein paar Zeilen wie arbeiten würde

auto foo = bla();

Wenn der Typ nullmal angegeben wird, möchte ich diese Zeilen möglicherweise so ändern, dass sie Typen enthalten. Das erste Beispiel ist großartig, da der Typ einmal angegeben wird und autowir nicht zweimal unordentliche Vorlagen schreiben müssen. Hurra für C ++++. Das explizite Null-malige Anzeigen des Typs, wenn er in einer nahe gelegenen Zeile nicht leicht sichtbar ist, macht mich nervös, zumindest in C ++ und seinen unmittelbaren Nachfolgern. Für andere Sprachen, die auf einer höheren Ebene mit mehr Abstraktion, Polymorphismus und Generizität arbeiten sollen, ist dies in Ordnung.

Bei C ++ und darüber hinaus 2012 gab es im Ask Us Anything- Panel einen fantastischen Austausch zwischen Andrei Alexandrescu, Scott Meyers und Herb Sutter, in dem darüber gesprochen wurde, wann und wann nichtauto . Fahren Sie mit Minute 25:03 fort, um eine 4-minütige Diskussion zu führen. Alle drei Lautsprecher bieten hervorragende Punkte, die beachtet werden sollten, wenn sie nicht verwendet werden auto.

Ich ermutige die Leute sehr, zu ihrem eigenen Schluss zu kommen, aber mein Mitnehmen war, es überall zu verwenden auto, es sei denn :

1. Es schadet der Lesbarkeit
2. Es gibt Bedenken hinsichtlich der automatischen Typkonvertierung (z. B. von Konstruktoren, Zuweisung, Vorlagenzwischen-Typen, implizite Konvertierung zwischen ganzzahligen Breiten).

Die liberale Verwendung von explicithilft, die Sorge um letztere zu verringern, was dazu beiträgt, die Zeit zu minimieren, die erstere ein Problem darstellen.

Formulieren Sie neu, was Herb gesagt hat: "Wenn Sie nicht X, Y und Z tun, verwenden Sie auto. Lernen Sie, was X, Y und Z sind, und gehen Sie weiter und verwenden Sie autoüberall anders."

Ja, es kann zu Lasten der Lesbarkeit überbeansprucht werden. Ich schlage vor, es in Kontexten zu verwenden, in denen genaue Typen lang oder unaussprechlich oder für die Lesbarkeit nicht wichtig sind und Variablen nur von kurzer Dauer sind. Zum Beispiel ist der Iteratortyp normalerweise lang und nicht wichtig, also autowürde es funktionieren:

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

auto Hier schadet die Lesbarkeit nicht.

Ein weiteres Beispiel ist der Parser-Regeltyp, der lang und kompliziert sein kann. Vergleichen Sie:

   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;

Wenn der Typ bekannt und einfach ist, ist es viel besser, wenn ausdrücklich angegeben wird:

int i = foo();

eher, als

auto i = foo();

auto kann in Kombination mit Ausdrucksvorlagen, die häufig von linearen Algebra-Bibliotheken wie Eigen oder OpenCV verwendet werden, sehr gefährlich sein.

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.

Fehler, die durch diese Art von Fehlern verursacht werden, sind ein großes Problem beim Debuggen. Eine mögliche Abhilfe besteht darin, das Ergebnis explizit in den erwarteten Typ umzuwandeln, wenn Sie Auto für den Deklarationsstil von links nach rechts verwenden möchten.

auto C = Matrix(A * B); // The expression is now evaluated immediately.

Ich benutze autoohne Einschränkung und hatte kein Problem. Ich benutze es sogar manchmal für einfache Typen wie int. Dies macht C ++ für mich zu einer höheren Sprache und ermöglicht das Deklarieren von Variablen in C ++ wie in Python. Nach dem Schreiben von Python-Code schreibe ich manchmal sogar z

auto i = MyClass();

anstatt

MyClass i;

Dies ist ein Fall, in dem ich sagen würde, dass es sich um einen Missbrauch des autoSchlüsselworts handelt.

Oft macht es mir nichts aus, was der genaue Typ des Objekts ist, ich interessiere mich mehr für seine Funktionalität, und da Funktionsnamen im Allgemeinen etwas über die Objekte aussagen, die sie zurückgeben, autotut das nicht weh: z. B. auto s = mycollection.size()kann ich mir vorstellen, dass dies sder Fall sein wird Eine Art Ganzzahl, und in dem seltenen Fall, in dem mir der genaue Typ am Herzen liegt, überprüfen wir dann den Funktionsprototyp (ich meine, ich muss lieber prüfen, wann ich die Informationen benötige, als a priori, wenn Code geschrieben wird) für den Fall, dass es eines Tages nützlich wäre, wie in int_type s = mycollection.size()).

Zu diesem Beispiel aus der akzeptierten Antwort:

for ( auto x = max_size; x > 0; --x )

In meinem Code verwende ich autoin diesem Fall immer noch, und wenn ich nicht xsigniert werden möchte , verwende ich eine Dienstprogrammfunktion namens say make_unsigned, die meine Bedenken klar zum Ausdruck bringt:

for ( auto x = make_unsigned(max_size); x > 0; --x )

Haftungsausschluss: Ich beschreibe nur meine Verwendung, ich bin nicht kompetent, Ratschläge zu geben!

Einer der wichtigsten Problem mit C ++ Programm ist es Ihnen die verwenden können nicht initialisierten Variablen . Dies führt uns zu einem unangenehmen, nicht deterministischen Programmverhalten. Es sollte beachtet werden, dass der moderne Compiler jetzt entsprechende / Meldungswarnmeldungen ausgibt, wenn das Programm müde wird, es zu verwenden.

Um dies zu veranschaulichen, betrachten Sie das folgende c ++ - Programm:

int main() {
    int x;
    int y = 0;
    y += x;
}

Wenn ich dieses Programm mit einem modernen Compiler (GCC) kompiliere, wird eine Warnung ausgegeben. Eine solche Warnung ist möglicherweise nicht sehr offensichtlich, wenn wir mit dem wirklich komplexen Produktionscode arbeiten.

main.cpp: In der Funktion 'int main ()':

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

y + = x;

    ^

================================================== ============================== Wenn wir nun unser Programm ändern, das auto verwendet , erhalten wir beim Kompilieren Folgendes:

int main() {
    auto x;
    auto y = 0;
    y += x;
}

main.cpp: In der Funktion 'int main ()':

main.cpp: 2: 10: Fehler : Die Deklaration von 'auto x' hat keinen Initialisierer

 auto x;

      ^

Mit auto ist es nicht möglich, die nicht initialisierte Variable zu verwenden. Dies ist ein großer Vorteil, den wir (kostenlos) erhalten können, wenn wir Auto verwenden .

Dieses Konzept und andere großartige moderne C ++ - Konzepte werden vom C ++ - Experten Herb Shutter in seinem CppCon14- Vortrag erklärt:

Zurück zu den Grundlagen! Grundlagen des modernen C ++ - Stils

Eine Gefahr, die ich festgestellt habe, sind Referenzen. z.B

MyBigObject& ref_to_big_object= big_object;
auto another_ref = ref_to_big_object; // ?

Das Problem ist, dass another_ref in diesem Fall keine Referenz ist. Es ist MyBigObject anstelle von MyBigObject &. Am Ende kopieren Sie ein großes Objekt, ohne es zu merken.

Wenn Sie eine Referenz direkt von einer Methode erhalten, denken Sie möglicherweise nicht darüber nach, was sie tatsächlich ist.

auto another_ref = function_returning_ref_to_big_object();

Sie würden "auto &" oder "const auto &" benötigen

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();

Verwenden autoSie diese Option, wenn ein Typ abgeleitet werden soll. Wenn Sie etwas haben, von dem Sie wissen, dass es eine Ganzzahl ist, oder wenn Sie wissen, dass es eine Zeichenfolge ist, verwenden Sie einfach int / std :: string usw. Ich würde mir keine Sorgen darüber machen, eine Sprachfunktion zu "überbeanspruchen", es sei denn, sie wird lächerlich. oder verschleiert Code.

Das ist sowieso meine Meinung.

autoDas Schlüsselwort kann nur für lokale Variablen verwendet werden, nicht für Argumente oder Klassen- / Strukturelemente. Es ist also sicher und praktikabel, sie überall dort einzusetzen, wo Sie möchten. Ich benutze sie oft. Der Typ wird zur Kompilierungszeit abgeleitet, der Debugger zeigt den Typ beim Debuggen an, sizeofmeldet ihn korrekt, decltypewürde den richtigen Typ angeben - es gibt keinen Schaden. Ich zähle nie autoals überstrapaziert!

TL; DR: Siehe Faustregel unten.

Die akzeptierte Antwort schlägt die folgende Faustregel vor:

Verwenden autoSie diese Option immer dann, wenn es schwierig ist zu sagen, wie der Typ auf den ersten Blick geschrieben werden soll, der Typ der rechten Seite eines Ausdrucks jedoch offensichtlich ist.

Aber ich würde sagen, das ist zu restriktiv. Manchmal interessieren mich die Typen nicht, da die Aussage informativ genug ist, ohne dass ich mir die Zeit nehme, den Typ herauszufinden. Was meine ich damit? Betrachten Sie das Beispiel, das in einigen Antworten aufgetaucht ist:

auto x = f();

Was macht dies zu einem Beispiel für Missbrauch auto? Ist es meine Unkenntnis des f()Rückgabetyps? Nun, es mag zwar helfen, wenn ich es wüsste, aber - das ist nicht mein Hauptanliegen. Was viel mehr ein Problem ist, ist das xund f()sind ziemlich bedeutungslos. Wenn wir hätten:

auto nugget = mine_gold();

Stattdessen ist es mir normalerweise egal, ob der Rückgabetyp der Funktion offensichtlich ist oder nicht. Wenn ich die Anweisung lese, weiß ich, was ich tue, und ich weiß genug über die Semantik des Rückgabewerts, um nicht das Gefühl zu haben, dass ich auch seinen Typ kennen muss.

Meine Antwort lautet also: Verwenden Sie, autowann immer der Compiler dies zulässt, es sei denn:

• Sie haben das Gefühl, dass der Variablenname zusammen mit dem Initialisierungs- / Zuweisungsausdruck nicht genügend Informationen darüber liefert, was die Anweisung tut.
• Sie glauben, dass der Variablenname zusammen mit dem Initialisierungs- / Zuweisungsausdruck "irreführende" Informationen darüber liefert, was der Typ sein sollte - dh wenn Sie raten müssten, was anstelle des Autos kommt, könnten Sie eine Vermutung anstellen - und das wäre es falsch, und diese falsche Annahme hat später im Code Auswirkungen.
• Sie möchten einen anderen Typ erzwingen (z. B. eine Referenz).

Und auch:

• Geben Sie lieber einen aussagekräftigen Namen (der natürlich nicht den Typnamen enthält), bevor Sie ihn durch autoden konkreten Typ ersetzen .

Eine meiner bitteren Erfahrungen mit autoist die Verwendung mit Lambda-Ausdrücken :

auto i = []() { return 0; };
cout<<"i = "<<i<<endl; // output: 1 !!!

Eigentlich wird hier ider Funktionszeiger von aufgelöst int(*)(). Dies ist nur eine einfache cout, aber stellen Sie sich vor, welche Art von fehlerhaften Kompilierungs- / Laufzeitfehlern sie bei Verwendung verursachen können template.

Sie sollten solche Ausdrücke vermeiden auto und einen geeigneten returnTyp (oder einen kontrollierten decltype()) eingeben.

Die korrekte Verwendung für das obige Beispiel wäre:

auto i = []() { return 0; }(); // and now i contains the result of calling the lambda