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

Ich habe die neue verwendet auto Schlüsselwort, das im C++11-Standard für komplizierte Vorlagentypen verfügbar ist, wofür es meines Erachtens entwickelt wurde. 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 viele Diskussionen zu diesem Thema gesehen. Es scheint, dass auto könnte überbeansprucht werden, da ein Typ oft eine Form der Dokumentation und Plausibilitätsprüfung ist. Wo ziehen Sie die Grenze bei der Verwendung auto und was sind die empfohlenen Anwendungsfälle für diese neue Funktion?

Zur Klarstellung: Ich bitte nicht um eine philosophische Meinung; Ich bitte um die bestimmungsgemäße Verwendung dieses Schlüsselworts durch das Standardkomitee, möglicherweise mit Kommentaren dazu, wie diese bestimmungsgemäße Verwendung in der Praxis realisiert wird.

Ich denke, dass man das nutzen sollte auto Schlüsselwort immer dann, wenn es auf den ersten Blick schwer zu sagen ist, wie man den Typ schreibt, aber der Typ auf der rechten Seite eines Ausdrucks offensichtlich ist. 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 zu erhalten, geben Sie ihn ein boost::multi_indexobwohl Sie wissen, dass es so ist int. Du kannst nicht einfach schreiben int weil es in Zukunft geändert werden könnte. ich würde schreiben auto in diesem Fall.

Also wenn die auto Schlüsselwort verbessert die Lesbarkeit in einem bestimmten Fall, dann verwenden Sie es. Du kannst schreiben auto wenn es für den Leser offensichtlich ist, welche Art auto repräsentiert.

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 auto wo immer Sie können – besonders const auto damit Nebenwirkungen weniger besorgniserregend sind. Sie müssen sich außer in den offensichtlichen Fällen keine Gedanken über Typen machen, aber sie werden trotzdem statisch für Sie verifiziert, und Sie können einige Wiederholungen vermeiden. Woher auto nicht machbar ist, können Sie verwenden decltype um Typen semantisch auszudrücken als Verträge basierend auf Ausdrücken. Ihr Code wird anders aussehen, aber es wird eine positive Änderung sein.

Leicht. Verwenden Sie es, wenn Sie egal was für ein typ ist. Zum Beispiel

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

Mir geht es hier nur darum i ist, was auch immer 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 h und w Floats oder Doubles sind, nur dass sie es sind welcher Typ geeignet ist, um Höhen und Gewichte auszudrücken.

Oder überlegen

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 so etwas wie Ententypisierung.

Auch die Art der Lambdas kann nicht buchstabiert werden auto f = []... ist guter Stil. Die Alternative ist Casting zu std::function aber das kommt mit Overhead.

Ich kann mir einen “Missbrauch” nicht wirklich vorstellen auto. Am ehesten kann ich mir vorstellen, dass Sie sich einer expliziten Konvertierung in einen signifikanten Typ berauben – aber Sie würden es nicht verwenden auto Dafür würden Sie ein Objekt des gewünschten Typs konstruieren.

Wenn du kann Entfernen Sie etwas Redundanz in Ihrem Code, ohne Nebenwirkungen einzuführen, und dann Muss sei gut dabei.

Gegenbeispiele (aus den Antworten von jemand anderem übernommen):

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

Hier kümmern wir uns um den Typ, also sollten wir schreiben Someclass i; und for(unsigned x = y;...

Tue es. Verwenden auto Überall macht es das Schreiben von Code einfacher.

Jede neue Funktion in jeder Sprache wird zumindest von einigen Arten von Programmierern überstrapaziert. Nur durch moderate Überbeanspruchung durch einige erfahrene Programmierer (keine Noobs) lernen die übrigen erfahrenen Programmierer die Grenzen des richtigen Gebrauchs kennen. Extreme Überbeanspruchung ist normalerweise schlecht, könnte aber gut sein, da eine solche Überbeanspruchung zu Verbesserungen der Funktion oder einer besseren Funktion führen kann, um sie zu ersetzen.

Aber wenn ich an Code mit mehr als ein paar Zeilen wie z

auto foo = bla();

Wo der Typ null Mal angegeben ist, 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 auto erspart uns das zweimalige Schreiben unordentlicher Vorlagentypen. Hurra für C++++. Aber das explizite Zeigen des Typs Null mal, wenn es nicht leicht in einer nahe gelegenen Zeile sichtbar ist, macht mich nervös, zumindest in C++ und seinen unmittelbaren Nachfolgern. Für andere Sprachen, die entwickelt wurden, um auf einer höheren Ebene mit mehr Abstraktion, Polymorphismus und Generizität zu arbeiten, ist es in Ordnung.

Bei C++ und darüber hinaus 2012 in dem Fragen Sie uns alles Panel, es gab eine fantastischer Austausch zwischen Andrei Alexandrescu, Scott Meyers und Herb Sutter, in dem es darum ging, wann man es benutzt und wann nicht auto. Springen Sie zu Minute 25:03 für eine 4-minütige Diskussion. Alle drei Redner geben hervorragende Punkte, die man im Hinterkopf behalten sollte nicht verwenden auto.

Ich ermutige die Leute sehr, zu ihren eigenen Schlussfolgerungen zu kommen, aber mein Fazit war es verwenden auto überall, überallhin, allerorts wenn nicht:

1. Es schadet der Lesbarkeit
2. Es bestehen Bedenken hinsichtlich der automatischen Typkonvertierung (z. B. von Konstruktoren, Zuweisungen, Template-Zwischentypen, implizite Konvertierung zwischen ganzzahligen Breiten).

Großzügiger Gebrauch von explicit hilft, die Sorge um Letzteres zu verringern, was dazu beiträgt, die Zeitdauer zu minimieren, in der Ersteres ein Problem darstellt.

Umformulieren, was Herb sagte: „Wenn Sie X, Y und Z nicht machen, verwenden Sie auto. Erfahren Sie, was X, Y und Z sind, und gehen Sie weiter und verwenden Sie es auto überall sonst.”

Ja, es kann zu Lasten der Lesbarkeit überstrapaziert werden. Ich schlage vor, es in Kontexten zu verwenden, in denen genaue Typen lang oder unaussprechlich oder für die Lesbarkeit nicht wichtig und Variablen kurzlebig sind. Beispielsweise ist der Iteratortyp normalerweise lang und daher nicht wichtig auto würde funktionieren:

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

auto hier tut der Lesbarkeit keinen Abbruch.

Ein weiteres Beispiel ist der Parser-Regeltyp, der lang und verschachtelt sein kann. 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 der Typ bekannt und einfach ist, ist es viel besser, wenn er explizit angegeben wird:

int i = foo();

eher, als

auto i = foo();

auto kann in Kombination mit Ausdrucksvorlagen, die häufig von Bibliotheken für lineare Algebra 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ßer Schmerz beim Debuggen. Eine mögliche Abhilfe besteht darin, das Ergebnis explizit in den erwarteten Typ umzuwandeln, wenn Sie unbedingt auto für den Deklarationsstil von links nach rechts verwenden möchten.

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