Wann sollte ich den automatischen Abzugstyp C ++ 14 verwenden?

Mit GCC 4.8.0 haben wir einen Compiler, der den automatischen Rückzugstypabzug unterstützt und Teil von C ++ 14 ist. Mit -std=c++1ykann ich das machen:

auto foo() { //deduced to be int
    return 5;
}

Meine Frage ist: Wann sollte ich diese Funktion verwenden? Wann ist es notwendig und wann wird der Code sauberer?

Szenario 1

Das erste Szenario, an das ich denken kann, ist wann immer möglich. Jede Funktion, die auf diese Weise geschrieben werden kann, sollte sein. Das Problem dabei ist, dass der Code möglicherweise nicht immer besser lesbar ist.

Szenario 2

Das nächste Szenario besteht darin, komplexere Rückgabetypen zu vermeiden. Als sehr leichtes Beispiel:

template<typename T, typename U>
auto add(T t, U u) { //almost deduced as decltype(t + u): decltype(auto) would
    return t + u;
}

Ich glaube nicht, dass dies jemals wirklich ein Problem sein würde, obwohl ich denke, dass es in einigen Fällen klarer sein könnte, wenn der Rückgabetyp explizit von den Parametern abhängt.

Szenario 3

Um Redundanz zu vermeiden:

auto foo() {
    std::vector<std::map<std::pair<int, double>, int>> ret;
    //fill ret in with stuff
    return ret;
}

In C ++ 11 können wir manchmal nur return {5, 6, 7};einen Vektor ersetzen, aber das funktioniert nicht immer und wir müssen den Typ sowohl im Funktionsheader als auch im Funktionskörper angeben. Dies ist rein redundant, und der automatische Abzug des Rückgabetyps erspart uns diese Redundanz.

Szenario 4

Schließlich kann es anstelle sehr einfacher Funktionen verwendet werden:

auto position() {
    return pos_;
}

auto area() {
    return length_ * width_;
}

Manchmal schauen wir uns jedoch die Funktion an, um den genauen Typ zu erfahren, und wenn sie dort nicht bereitgestellt wird, müssen wir zu einem anderen Punkt im Code gehen, z. B. wo pos_deklariert wird.

Fazit

Welche dieser Szenarien erweisen sich bei diesen Szenarien tatsächlich als eine Situation, in der diese Funktion hilfreich ist, um den Code sauberer zu gestalten? Was ist mit Szenarien, die ich hier nicht erwähnt habe? Welche Vorsichtsmaßnahmen sollte ich treffen, bevor ich diese Funktion verwende, damit sie mich später nicht beißt? Gibt es etwas Neues, das diese Funktion auf den Tisch bringt und das ohne sie nicht möglich ist?

_{Beachten Sie, dass die mehreren Fragen dazu dienen sollen, Perspektiven zu finden, aus denen diese beantwortet werden können.}

C ++ 11 wirft ähnliche Fragen auf: Wann wird der Rückgabetypabzug in Lambdas verwendet und wann werden autoVariablen verwendet ?

Die traditionelle Antwort auf die Frage in C und C ++ 03 lautete: "Über Anweisungsgrenzen hinweg machen wir Typen explizit, innerhalb von Ausdrücken sind sie normalerweise implizit, aber wir können sie mit Casts explizit machen". C ++ 11 und C ++ 1y führen Typabzugswerkzeuge ein, damit Sie den Typ an neuen Stellen weglassen können.

Entschuldigung, aber Sie werden dies nicht im Voraus lösen, indem Sie allgemeine Regeln festlegen. Sie müssen sich einen bestimmten Code ansehen und selbst entscheiden, ob er die Lesbarkeit verbessert, um überall Typen anzugeben: Ist es besser, wenn Ihr Code sagt: "Der Typ dieser Sache ist X", oder ist es besser für Ihr Code sagt: "Der Typ dieser Sache ist für das Verständnis dieses Teils des Codes irrelevant: Der Compiler muss es wissen und wir könnten es wahrscheinlich herausfinden, aber wir müssen es hier nicht sagen."

Da "Lesbarkeit" nicht objektiv definiert ist [*] und darüber hinaus je nach Leser unterschiedlich ist, haben Sie als Autor / Herausgeber eines Codes die Verantwortung, die von einem Styleguide nicht vollständig erfüllt werden kann. Selbst in dem Maße, in dem ein Styleguide Normen festlegt, bevorzugen unterschiedliche Personen unterschiedliche Normen und neigen dazu, etwas Unbekanntes als "weniger lesbar" zu empfinden. Daher kann die Lesbarkeit einer bestimmten vorgeschlagenen Stilregel häufig nur im Kontext der anderen vorhandenen Stilregeln beurteilt werden.

Alle Ihre Szenarien (auch die ersten) werden für den Codierungsstil einer Person Verwendung finden. Persönlich finde ich, dass der zweite der überzeugendste Anwendungsfall ist, aber ich gehe trotzdem davon aus, dass er von Ihren Dokumentationstools abhängt. Es ist nicht sehr hilfreich zu sehen, dass der Rückgabetyp einer Funktionsvorlage autodokumentiert ist , während die Dokumentation decltype(t+u)eine veröffentlichte Schnittstelle erstellt, auf die Sie sich (hoffentlich) verlassen können.

[*] Gelegentlich versucht jemand, objektive Messungen durchzuführen. In dem geringen Maße, dass jemand jemals statistisch signifikante und allgemein gültige Ergebnisse erzielt, werden sie von arbeitenden Programmierern zugunsten des Instinkts des Autors, was "lesbar" ist, völlig ignoriert.

Im Allgemeinen ist der Rückgabetyp der Funktion eine große Hilfe, um eine Funktion zu dokumentieren. Der Benutzer wird wissen, was erwartet wird. Es gibt jedoch einen Fall, in dem es meiner Meinung nach hilfreich sein könnte, diesen Rückgabetyp zu löschen, um Redundanz zu vermeiden. Hier ist ein Beispiel:

template<typename F, typename Tuple, int... I>
  auto
  apply_(F&& f, Tuple&& args, int_seq<I...>) ->
  decltype(std::forward<F>(f)(std::get<I>(std::forward<Tuple>(args))...))
  {
    return std::forward<F>(f)(std::get<I>(std::forward<Tuple>(args))...);
  }

template<typename F, typename Tuple,
         typename Indices = make_int_seq<std::tuple_size<Tuple>::value>>
  auto
  apply(F&& f, Tuple&& args) ->
  decltype(apply_(std::forward<F>(f), std::forward<Tuple>(args), Indices()))
  {
    return apply_(std::forward<F>(f), std::forward<Tuple>(args), Indices());
  }

Dieses Beispiel stammt aus dem offiziellen Ausschusspapier N3493 . Der Zweck der Funktion applybesteht darin, die Elemente von a std::tuplean eine Funktion weiterzuleiten und das Ergebnis zurückzugeben. Die int_seqund make_int_seqsind nur ein Teil der Implementierung und werden wahrscheinlich nur Benutzer verwirren, die versuchen zu verstehen, was sie tun.

Wie Sie sehen können, ist der Rückgabetyp nichts anderes als ein decltypezurückgegebener Ausdruck. Da apply_ich nicht dafür gedacht bin, von den Benutzern gesehen zu werden, bin ich mir nicht sicher, ob es nützlich ist, den Rückgabetyp zu dokumentieren, wenn er mehr oder weniger dem von ihm entspricht apply. Ich denke, dass in diesem speziellen Fall das Löschen des Rückgabetyps die Funktion lesbarer macht. Beachten Sie, dass genau dieser Rückgabetyp decltype(auto)im Vorschlag zur Ergänzung applydes Standards N3915 tatsächlich gelöscht und durch ersetzt wurde (beachten Sie auch, dass meine ursprüngliche Antwort älter ist als dieses Papier):

template <typename F, typename Tuple, size_t... I>
decltype(auto) apply_impl(F&& f, Tuple&& t, index_sequence<I...>) {
    return forward<F>(f)(get<I>(forward<Tuple>(t))...);
}

template <typename F, typename Tuple>
decltype(auto) apply(F&& f, Tuple&& t) {
    using Indices = make_index_sequence<tuple_size<decay_t<Tuple>>::value>;
    return apply_impl(forward<F>(f), forward<Tuple>(t), Indices{});
}

In den meisten Fällen ist es jedoch besser, diesen Rückgabetyp beizubehalten. In dem oben beschriebenen speziellen Fall ist der Rückgabetyp ziemlich unlesbar und ein potenzieller Benutzer wird nichts davon haben, ihn zu kennen. Eine gute Dokumentation mit Beispielen ist weitaus nützlicher.

Eine andere Sache, die noch nicht erwähnt wurde: Während declype(t+u)die Verwendung des Ausdrucks SFINAE erlaubt ist , ist decltype(auto)dies nicht der Fall (obwohl es einen Vorschlag gibt , dieses Verhalten zu ändern). Nehmen Sie zum Beispiel eine foobarFunktion, die die fooMitgliedsfunktion eines Typs baraufruft, wenn sie existiert, oder die Mitgliedsfunktion des Typs, wenn sie existiert, und nehmen Sie an, dass eine Klasse immer genau foooder baraber nicht beide gleichzeitig hat:

struct X
{
    void foo() const { std::cout << "foo\n"; }
};

struct Y
{
    void bar() const { std::cout << "bar\n"; }
};

template<typename C> 
auto foobar(const C& c) -> decltype(c.foo())
{
    return c.foo();
}

template<typename C> 
auto foobar(const C& c) -> decltype(c.bar())
{
    return c.bar();
}

Das Aufrufen foobareiner Instanz von Xwird angezeigt, foowährend das Aufrufen foobareiner Instanz von Yangezeigt wird bar. Wenn Sie stattdessen den automatischen Rückgabetypabzug verwenden (mit oder ohne decltype(auto)), erhalten Sie keinen Ausdruck SFINAE und rufen foobareine Instanz von entweder auf Xoder Ylösen einen Fehler bei der Kompilierung aus.

Es ist niemals notwendig. Wann Sie sollten - Sie werden viele verschiedene Antworten darauf erhalten. Ich würde überhaupt nicht sagen, bis es tatsächlich ein akzeptierter Teil des Standards ist und von der Mehrheit der großen Compiler auf die gleiche Weise gut unterstützt wird.

Darüber hinaus wird es ein religiöses Argument sein. Ich persönlich würde sagen, dass das Nicht-Eingeben des tatsächlichen Rückgabetyps den Code klarer macht, für die Wartung viel einfacher ist (ich kann die Signatur einer Funktion überprüfen und wissen, was sie zurückgibt, anstatt den Code tatsächlich lesen zu müssen), und dies beseitigt die Möglichkeit, dass Sie denken, es sollte einen Typ zurückgeben, und der Compiler glaubt, dass ein anderer Probleme verursacht (wie es bei jeder Skriptsprache passiert ist, die ich jemals verwendet habe). Ich denke, Auto war ein riesiger Fehler und es wird um Größenordnungen mehr Schmerz als Hilfe verursachen. Andere werden sagen, Sie sollten es die ganze Zeit verwenden, da es zu ihrer Programmierphilosophie passt. In jedem Fall liegt dies außerhalb des Geltungsbereichs dieser Website.

Es hat nichts mit der Einfachheit der Funktion zu tun (wie ein jetzt gelöschtes Duplikat dieser Frage angenommen wird).

Entweder ist der Rückgabetyp fest (nicht verwenden auto) oder in komplexer Weise von einem Vorlagenparameter abhängig ( autoin den meisten Fällen verwendet, gepaart mit, decltypewenn mehrere Rückgabepunkte vorhanden sind).

Stellen Sie sich eine reale Produktionsumgebung vor: Viele Funktionen und Komponententests hängen alle vom Rückgabetyp von ab foo(). Angenommen, der Rückgabetyp muss aus irgendeinem Grund geändert werden.

Wenn der Rückgabetyp autoüberall ist und Aufrufer foo()und verwandte Funktionen autobeim Abrufen des zurückgegebenen Werts verwenden, sind die erforderlichen Änderungen minimal. Wenn nicht, könnte dies Stunden extrem mühsamer und fehleranfälliger Arbeit bedeuten.

Als Beispiel aus der Praxis wurde ich gebeten, ein Modul von der Verwendung von Rohzeigern überall auf intelligente Zeiger umzustellen. Das Reparieren der Unit-Tests war schmerzhafter als der eigentliche Code.

Es gibt zwar andere Möglichkeiten, wie dies gehandhabt werden könnte, aber die Verwendung von autoRückgabetypen scheint gut zu passen.

Ich möchte ein Beispiel geben, in dem der Rückgabetyp auto perfekt ist:

Stellen Sie sich vor, Sie möchten einen kurzen Alias ​​für einen langen nachfolgenden Funktionsaufruf erstellen. Mit auto müssen Sie sich nicht um den ursprünglichen Rückgabetyp kümmern (möglicherweise ändert er sich in Zukunft), und der Benutzer kann auf die ursprüngliche Funktion klicken, um den tatsächlichen Rückgabetyp zu erhalten:

inline auto CreateEntity() { return GetContext()->GetEntityManager()->CreateEntity(); }

PS: Kommt auf diese Frage an.

Für Szenario 3 würde ich den Rückgabetyp der Funktionssignatur mit der lokalen Variablen drehen, die zurückgegeben werden soll. Dies würde es für Client-Programmierer klarer machen, wenn die Funktion zurückgegeben wird. So was:

Szenario 3 So verhindern Sie Redundanz:

std::vector<std::map<std::pair<int, double>, int>> foo() {
    decltype(foo()) ret;
    return ret;
}

Ja, es gibt kein Auto-Schlüsselwort, aber der Principal ist derselbe, um Redundanz zu vermeiden und Programmierern, die keinen Zugriff auf die Quelle haben, die Arbeit zu erleichtern.