Wann sollte ich den automatischen Rückgabetyp C ++ 14 verwenden?

Allgemein gesprochen, die Funktion Rückgabetyp ist eine große Hilfe-Dokument eine Funktion. Die Benutzer werden wissen, was zu erwarten ist. Es gibt jedoch auch einen Fall, wo ich denke, es könnte nett sein, zu fallen, zurück geben, 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());
  }

Diesem Beispiel ist entnommen aus der offiziellen Ausschuss Papier N3493. Der Zweck der Funktion apply ist es uns, die Elemente einer std::tuple Sie zu einer Funktion und zur Rückgabe des Ergebnisses. Die int_seq und make_int_seq sind nur ein Teil der Implementierung und wird wahrscheinlich nur verwirren Anwender, die versuchen zu verstehen, was es tut.

Wie Sie sehen können, ist der Rückgabetyp ist nichts mehr als eine decltype des Ausdruck zurückgegeben. Darüber hinaus apply_ nicht gemeint, gesehen zu werden von den Usern, ich bin nicht sicher, dass die Nützlichkeit der Dokumentation seiner Rückkehr geben, wenn es mehr oder weniger das gleiche wie apply's ein. Ich denke, dass in diesem speziellen Fall fallen die return-Typ macht die Funktion mehr lesbar. Beachten Sie, dass diese sehr Rückgabetyp hat eigentlich schon fallen gelassen und ersetzt durch decltype(auto) im Vorschlag hinzufügen apply standard, N3915 (beachten Sie auch, dass meine ursprüngliche Antwort, die älter als das 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{});
}

Jedoch, die meisten der Zeit, ist es besser zu halten, zurück geben. In dem besonderen Fall, dass ich oben beschrieben habe, ist der Rückgabetyp ist eher unlesbar und potenzielle Nutzer nicht gewinnen alles, was es zu wissen. Eine gute Dokumentation mit Beispielen werden weit mehr nützlich.

Andere Sache, die nicht erwähnt wurden und doch: während declype(t+u) ermöglicht Ausdruck SFINAE, decltype(auto) nicht (obwohl es ist ein Vorschlag, um dieses Verhalten ändern). Nehmen Sie zum Beispiel eine foobar Funktion aufrufen, werden ein Typ ist foo member-Funktion, wenn es vorhanden ist, oder Aufruf des Typs bar member-Funktion, falls es vorhanden ist, und davon ausgehen, dass eine Klasse hat immer exacty foo oder bar aber weder beides zugleich:

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

Aufrufen foobar auf eine Instanz von X zeigt foo beim Aufruf foobar auf eine Instanz von Y zeigt bar. Wenn Sie die automatische Rückgabetyp Abzug statt (mit oder ohne decltype(auto)), Sie erhalten nicht Ausdruck SFINAE und ruft foobar auf eine Instanz von X oder Y löst eine compile-time-Fehler.

InformationsquelleAutor der Antwort Morwenn

Es ist nie notwendig. Wann sollten Sie - Sie gehen zu bekommen eine Menge von verschiedenen Antworten zu. Ich würde sagen überhaupt nicht, bis Ihr tatsächlich ein akzeptierter Teil der standard-und gut unterstützt durch die Mehrheit der wichtigen Compiler der gleichen Weise.

Darüber hinaus, sein wird, ein religiöses argument. Ich würde persönlich sagen, noch nie - setzen in der tatsächlichen Rückgabetyp der code dadurch übersichtlicher, viel einfacher für die Wartung (kann ich eine Funktion, Unterschrift und wissen, was es gibt vs, tatsächlich mit, den code zu Lesen), und es entfällt die Möglichkeit, dass Sie denken, sollte es wieder einen geben und der compiler denkt, dass andere Probleme verursacht (so geschehen mit jeder Skript-Sprache, die ich je benutzt habe). Ich denke, dass auto war ein Riesen Fehler und es wird zu um Größenordnungen mehr Schmerzen als helfen. Andere sagen man soll es verwenden, die ganze Zeit, wie es passt Ihre Philosophie der Programmierung. Jedenfalls, das ist weit außerhalb des Gültigkeitsbereichs für diese Website.

InformationsquelleAutor der Antwort Gabe Sechan

Möchte ich ein Beispiel geben, wo Rückgabetyp auto ist perfekt:

Vorstellen, die Sie erstellen möchten, einen kurzen alias für eine lange anschließende Aufruf der Funktion. Mit dem auto brauchen Sie nicht zu kümmern sich um die ursprünglichen Rückgabetyp (vielleicht wird es sich in Zukunft ändern), und die Benutzer können auf die ursprüngliche Funktion zu erhalten, die Reale Rendite, Typ:

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

PS: Hängt davon ab, diese Frage.

InformationsquelleAutor der Antwort kaiser