Gibt es einen Nachteil beim Deklarieren von Variablen mit auto in C ++?

Es scheint, dass dies autoeine ziemlich wichtige Funktion war, die in C ++ 11 hinzugefügt wurde und die vielen neueren Sprachen zu folgen scheint. Wie bei einer Sprache wie Python habe ich keine explizite Variablendeklaration gesehen (ich bin nicht sicher, ob es mit Python-Standards möglich ist).

Gibt es einen Nachteil bei autoder Deklaration von Variablen, anstatt sie explizit zu deklarieren?

Sie haben nur nach Nachteilen gefragt, deshalb hebe ich einige davon hervor. Wenn es gut verwendet wird, autohat es auch mehrere Vorteile. Die Nachteile resultieren aus der Leichtigkeit des Missbrauchs und dem erhöhten Potenzial für Code, sich unbeabsichtigt zu verhalten.

Der Hauptnachteil besteht darin, dass Sie bei der Verwendung autonicht unbedingt den Typ des zu erstellenden Objekts kennen. Es gibt auch Fälle, in denen der Programmierer erwartet, dass der Compiler einen Typ ableitet, der Compiler jedoch unerbittlich einen anderen.

Gegeben eine Erklärung wie

auto result = CallSomeFunction(x,y,z);

Sie wissen nicht unbedingt, um welchen Typ es sich resulthandelt. Es könnte ein sein int. Es könnte ein Zeiger sein. Es könnte etwas anderes sein. Alle diese unterstützen unterschiedliche Operationen. Sie können den Code auch durch eine geringfügige Änderung wie dramatisch ändern

auto result = CallSomeFunction(a,y,z);

Denn je nachdem, welche Überladungen für CallSomeFunction()den Ergebnistyp vorhanden sind, kann dies völlig anders sein - und nachfolgender Code kann sich daher völlig anders verhalten als beabsichtigt. Sie könnten plötzlich Fehlermeldungen in späterem Code auslösen (z. B. versuchen Sie anschließend, eine dereferenzieren intund etwas zu ändern, was jetzt ist const). Die unheimlichere Änderung ist, wo Ihre Änderung am Compiler vorbeigeht, aber nachfolgender Code sich auf unterschiedliche und unbekannte - möglicherweise fehlerhafte - Weise verhält.

Wenn der Typ einiger Variablen nicht explizit bekannt ist, ist es daher schwieriger, eine Behauptung, dass der Code wie beabsichtigt funktioniert, rigoros zu rechtfertigen. Dies bedeutet mehr Aufwand, um Behauptungen von "Zweckmäßigkeit" in Bereichen mit hoher Kritikalität (z. B. sicherheitskritisch oder geschäftskritisch) zu rechtfertigen.

Der andere, häufigere Nachteil ist die Versuchung eines Programmierers, autoals stumpfes Instrument das Kompilieren von Code zu erzwingen, anstatt darüber nachzudenken, was der Code tut, und daran zu arbeiten, ihn richtig zu machen.

Dies ist kein autoprinzipieller Nachteil , aber in der Praxis scheint es für einige ein Problem zu sein. Grundsätzlich können manche Menschen entweder: a) autoals Retter für Typen behandeln und ihr Gehirn abschalten, wenn sie es verwenden, oder b) vergessen, dass dies autoimmer zu Werttypen führt. Dies führt dazu, dass Menschen solche Dinge tun:

auto x = my_obj.method_that_returns_reference();

Hoppla, wir haben gerade ein Objekt tief kopiert. Es ist oft entweder ein Fehler oder ein Leistungsfehler. Dann können Sie auch in die andere Richtung schwingen:

const auto& stuff = *func_that_returns_unique_ptr();

Jetzt erhalten Sie eine baumelnde Referenz. Diese Probleme werden überhaupt nicht verursacht auto, daher halte ich sie nicht für legitime Argumente dagegen. Aber es scheint, autodass diese Probleme (aus meiner persönlichen Erfahrung) aus den Gründen, die ich am Anfang aufgeführt habe, häufiger auftreten.

Ich denke, mit der Zeit werden sich die Menschen anpassen und die Arbeitsteilung verstehen: autoleitet den zugrunde liegenden Typ ab, aber Sie möchten immer noch über Referenz und Konstanz nachdenken. Aber es dauert ein bisschen.

Andere Antworten erwähnen Nachteile wie "Sie wissen nicht wirklich, was der Typ einer Variablen ist." Ich würde sagen, dass dies größtenteils mit der schlampigen Namenskonvention im Code zusammenhängt. Wenn Ihre Schnittstellen eindeutig benannt sind, sollten Sie sich nicht um den genauen Typ kümmern müssen . Klar, auto result = callSomeFunction(a, b);sagt dir nicht viel. Aber auto valid = isValid(xmlFile, schema);sagt Ihnen genug, um zu verwenden, validohne sich um den genauen Typ kümmern zu müssen. Schließlich if (callSomeFunction(a, b))würden Sie mit just auch den Typ nicht kennen. Das Gleiche gilt für alle anderen temporären Objekte mit Unterausdrücken. Ich halte dies also nicht für einen wirklichen Nachteil auto.

Ich würde sagen, der Hauptnachteil ist, dass manchmal der genaue Rückgabetyp nicht das ist , mit dem Sie arbeiten möchten. Tatsächlich unterscheidet sich der tatsächliche Rückgabetyp manchmal vom "logischen" Rückgabetyp als Implementierungs- / Optimierungsdetail. Ausdrucksvorlagen sind ein Paradebeispiel. Nehmen wir an, wir haben Folgendes:

SomeType operator* (const Matrix &lhs, const Vector &rhs);

Logischerweise würden wir erwarten , SomeTypezu sein Vector, und wir wollen es auf jeden Fall als solche behandeln in unserem Code. Es ist jedoch möglich, dass die von uns verwendete Algebra-Bibliothek zu Optimierungszwecken Ausdrucksvorlagen implementiert. Der tatsächliche Rückgabetyp lautet wie folgt:

MultExpression<Matrix, Vector> operator* (const Matrix &lhs, const Vector &rhs);

Nun ist das Problem, dass MultExpression<Matrix, Vector>aller Wahrscheinlichkeit nach ein const Matrix&und const Vector&intern gespeichert wird ; Es erwartet, dass es Vectorvor dem Ende seines vollständigen Ausdrucks in a konvertiert wird . Wenn wir diesen Code haben, ist alles in Ordnung:

extern Matrix a, b, c;
extern Vector v;

void compute()
{
  Vector res = a * (b * (c * v));
  // do something with res
}

Wenn wir autohier verwendet hätten, könnten wir jedoch in Schwierigkeiten geraten:

void compute()
{
  auto res = a * (b * (c * v));
  // Oops! Now `res` is referring to temporaries (such as (c * v)) which no longer exist
}

Einer der Nachteile ist , dass man manchmal nicht erklären kann const_iteratormit auto. In diesem Beispiel für Code aus dieser Frage erhalten Sie einen normalen (nicht konstanten) Iterator :

map<string,int> usa;
//...init usa
auto city_it = usa.find("New York");

Es macht das Lesen Ihres Codes etwas schwieriger oder mühsamer. Stellen Sie sich so etwas vor:

auto output = doSomethingWithData(variables);

Um nun die Art der Ausgabe herauszufinden, müssten Sie die Signatur der doSomethingWithDataFunktion aufspüren .

Wie dieser Entwickler hasse ich auto. Oder besser gesagt, ich hasse es, wie Menschen missbrauchen auto.

Ich bin der (starken) Meinung, dass autoes Ihnen helfen soll, generischen Code zu schreiben, und nicht, die Eingabe zu reduzieren .
C ++ ist eine Sprache, deren Ziel es ist, robusten Code zu schreiben und die Entwicklungszeit nicht zu minimieren.
Dies ist aus vielen Funktionen von C ++ ziemlich offensichtlich, aber leider autoreduzieren einige der neueren Funktionen, die das Tippen reduzieren, die Leute in die Irre, zu denken, sie sollten anfangen, faul mit dem Tippen zu sein.

In früheren autoZeiten verwendeten die Leute typedefs, was großartig war, weil typedef der Designer der Bibliothek Ihnen dabei half, herauszufinden, wie der Rückgabetyp aussehen sollte, damit ihre Bibliothek wie erwartet funktioniert. Wenn Sie verwenden auto, entfernen Sie dieses Steuerelement vom Designer der Klasse und bitten stattdessen den Compiler , herauszufinden, welcher Typ sein soll. Dadurch wird eines der leistungsstärksten C ++ - Tools aus der Toolbox entfernt und es besteht die Gefahr, dass der Code beschädigt wird.

Wenn Sie verwenden auto, sollte dies im Allgemeinen daran liegen, dass Ihr Code für jeden vernünftigen Typ funktioniert , und nicht daran, dass Sie einfach zu faul sind, den Typ aufzuschreiben, mit dem er funktionieren soll. Wenn Sie autoals Tool zur Unterstützung der Faulheit verwenden, führen Sie schließlich subtile Fehler in Ihr Programm ein, die normalerweise durch implizite Konvertierungen verursacht werden, die aufgrund Ihrer Verwendung nicht aufgetreten sind auto.

Leider sind diese Fehler in einem kurzen Beispiel hier nur schwer zu veranschaulichen , da sie aufgrund ihrer Kürze weniger überzeugend sind als die tatsächlichen Beispiele in einem Benutzerprojekt. Sie treten jedoch leicht in vorlagenlastigem Code auf, für den bestimmte implizite Konvertierungen erforderlich sind Ort.

Wenn Sie ein Beispiel möchten, gibt es hier eines . Ein kleiner Hinweis: Bevor Sie versucht sind, den Code zu überspringen und zu kritisieren, denken Sie daran, dass viele bekannte und ausgereifte Bibliotheken um solche impliziten Konvertierungen herum entwickelt wurden und sie vorhanden sind, weil sie Probleme lösen , die schwierig, wenn nicht unmöglich sein können anders zu lösen. Versuchen Sie, eine bessere Lösung zu finden, bevor Sie sie kritisieren.

autohat keine Nachteile für sich , und ich befürworte bis (Hand-wavily) verwenden Sie es überall in den neuen Code. Es ermöglicht Ihrem Code eine konsistente Typprüfung und ein konsistentes Silent Slicing. (Wenn Babgeleitet von Aund eine zurückgebende Funktion Aplötzlich zurückkehrt B, autoverhält sie sich wie erwartet, um ihren Rückgabewert zu speichern.)

Legacy-Code vor C ++ 11 kann jedoch auf impliziten Konvertierungen beruhen, die durch die Verwendung explizit typisierter Variablen induziert werden. Wenn Sie eine explizit typisierte Variable autoändern , um das Codeverhalten zu ändern , sollten Sie vorsichtig sein.

Das Schlüsselwort autoleitet den Typ einfach vom Rückgabewert ab. Daher ist es nicht gleichbedeutend mit einem Python-Objekt, z

# Python
a
a = 10       # OK
a = "10"     # OK
a = ClassA() # OK

// C++
auto a;      // Unable to deduce variable a
auto a = 10; // OK
a = "10";    // Value of const char* can't be assigned to int
a = ClassA{} // Value of ClassA can't be assigned to int
a = 10.0;    // OK, implicit casting warning

Da autoes während der Kompilierung abgeleitet wird, hat es zur Laufzeit keinerlei Nachteile.

Was hier bisher niemand erwähnt hat, aber für sich ist eine Antwort wert, wenn Sie mich fragen.

Da (auch wenn jeder wissen sollte, dass C != C++) in C geschriebener Code leicht als Basis für C ++ - Code entworfen werden kann und daher ohne großen Aufwand entworfen werden kann, um C ++ - kompatibel zu sein, könnte dies eine Voraussetzung für das Design sein.

Ich kenne einige Regeln, für die einige gut definierte Konstrukte Cungültig sind C++und umgekehrt. Dies würde jedoch einfach zu fehlerhaften ausführbaren Dateien führen, und es gilt die bekannte UB-Klausel, die meistens durch seltsame Schleifen bemerkt wird, die zu Abstürzen oder was auch immer führen (oder sogar unentdeckt bleiben können, aber das spielt hier keine Rolle).

Aber auto ist das erste Mal ¹ diese Änderungen!

Stellen Sie sich vor, Sie haben zuvor autoals Speicherklassenspezifizierer verwendet und übertragen den Code. Es würde nicht einmal notwendigerweise (abhängig von der Art und Weise, wie es verwendet wurde) "brechen"; es könnte tatsächlich stillschweigend das Verhalten des Programms ändern.

Daran sollte man denken.

¹ _{Zumindest das erste Mal, dass ich es weiß.}

Ein Grund, an den ich denken kann, ist, dass Sie die Gelegenheit verlieren, die zurückgegebene Klasse zu zwingen. Wenn Ihre Funktion oder Methode ein langes 64-Bit zurückgegeben hat und Sie nur ein 32-Int ohne Vorzeichen wollten, verlieren Sie die Möglichkeit, dies zu steuern.

Wie ich in dieser Antwort beschrieben habe,auto kann es manchmal zu funkigen Situationen kommen, die Sie nicht beabsichtigt haben. Sie müssen explizit sagen auto&, um einen Referenztyp zu haben, während Sie nur einen Zeigertyp autoerstellen können. Dies kann zu Verwirrung führen, indem der Spezifizierer insgesamt weggelassen wird, was zu einer Kopie der Referenz anstelle einer tatsächlichen Referenz führt.

Ein weiteres irritierendes Beispiel:

for (auto i = 0; i < s.size(); ++i)

generiert eine Warnung ( comparison between signed and unsigned integer expressions [-Wsign-compare]), da ies sich um ein signiertes int handelt. Um dies zu vermeiden, müssen Sie z

for (auto i = 0U; i < s.size(); ++i)

oder vielleicht besser:

for (auto i = 0ULL; i < s.size(); ++i)

Ich denke, es autoist gut, wenn es in einem lokalisierten Kontext verwendet wird, in dem der Leser seinen Typ leicht und offensichtlich ableiten kann, oder gut dokumentiert mit einem Kommentar seines Typs oder einem Namen, der auf den tatsächlichen Typ schließen lässt. Diejenigen, die nicht verstehen, wie es funktioniert, nehmen es möglicherweise falsch, wie wenn sie es anstelle von templateoder ähnlich verwenden. Hier sind meiner Meinung nach einige gute und schlechte Anwendungsfälle.

void test (const int & a)
{
    // b is not const
    // b is not a reference

    auto b = a;

    // b type is decided by the compiler based on value of a
    // a is int
}

Gute Verwendung

Iteratoren

std::vector<boost::tuple<ClassWithLongName1,std::vector<ClassWithLongName2>,int> v();

..

std::vector<boost::tuple<ClassWithLongName1,std::vector<ClassWithLongName2>,int>::iterator it = v.begin();

// VS

auto vi = v.begin();

Funktionszeiger

int test (ClassWithLongName1 a, ClassWithLongName2 b, int c)
{
    ..
}

..

int (*fp)(ClassWithLongName1, ClassWithLongName2, int) = test;

// VS

auto *f = test;

Schlechte Verwendung

Datenfluss

auto input = "";

..

auto output = test(input);

Funktionssignatur

auto test (auto a, auto b, auto c)
{
    ..
}

Trivialfälle

for(auto i = 0; i < 100; i++)
{
    ..
}

Ich bin überrascht, dass dies niemand erwähnt hat, aber nehmen wir an, Sie berechnen die Fakultät von etwas:

#include <iostream>
using namespace std;

int main() {
    auto n = 40;
    auto factorial = 1;

    for(int i = 1; i <=n; ++i)
    {
        factorial *= i;
    }

    cout << "Factorial of " << n << " = " << factorial <<endl;   
    cout << "Size of factorial: " << sizeof(factorial) << endl; 
    return 0;
}

Dieser Code gibt Folgendes aus:

Factorial of 40 = 0
Size of factorial: 4

Das war definitiv nicht das erwartete Ergebnis. Dies geschah, weil autoder Typ der Variablen Fakultät abgeleitet wurde, intweil sie zugewiesen wurde 1.