Was sind einige Anwendungen von decltype (auto)?

In c++14 den decltype(auto) idiom eingeführt.

In der Regel seine Verwendung ist für ermöglichen auto Erklärungen zur Verwendung der decltype Regeln, die auf dem gegebenen Ausdruck.

Suche für Beispiele von "guten" Gebrauch der Redewendung kann ich nur denken, Dinge wie die folgenden (von Scott Meyers), nämlich für eine Funktion Rückgabetyp Abzug:

template<typename ContainerType, typename IndexType>                //C++14
decltype(auto) grab(ContainerType&& container, IndexType&& index)
{
  authenticateUser();
  return std::forward<ContainerType>(container)[std::forward<IndexType>(index)];
}

Gibt es andere Beispiele, wo dieses neue feature sinnvoll ist?

InformationsquelleAutor der Frage Nikos Athanasiou | 2014-06-08

  1. 108

    Rückgabetyp Weiterleitung in generischen code -

    Für nicht-generischer code wie im ersten Beispiel, das Sie Gaben, können Sie Sie manuell auswählen, um eine Referenz als return-Typ:

    auto const& Example(int const& i) 
{ 
    return i; 
}

    aber in generischen code - Sie wollen in der Lage sein, um perfekt vorwärts, einen zurück gebenohne zu wissen, ob es sich um eine Referenz oder einen Wert. decltype(auto) gibt Ihnen die Möglichkeit:

    template<class Fun, class... Args>
decltype(auto) Example(Fun fun, Args&&... args) 
{ 
    return fun(std::forward<Args>(args)...); 
}

    Verzögerung Rückgabetyp Abzug in rekursiven templates

    In dieses Q&A vor ein paar Tagen, eine unendliche Rekursion bei template-Instanziierung wurde gefunden, wenn der Rückgabetyp der Vorlage angegeben wurde als decltype(iter(Int<i-1>{})) statt decltype(auto).

    template<int i> 
struct Int {};

constexpr auto iter(Int<0>) -> Int<0>;

template<int i>
constexpr auto iter(Int<i>) -> decltype(auto) 
{ return iter(Int<i-1>{}); }

int main() { decltype(iter(Int<10>{})) a; }

    decltype(auto) wird hier verwendet, um Verzögerung der Rückgabetyp Abzugnachdem sich der Staub der template-Instanziierung niedergelassen hat.

    Anderen verwendet

    Können Sie auch decltype(auto) in anderen Kontexten, z.B. dem Norm-Entwurf N3936 auch Staaten

    7.1.6.4 auto-Planer [dcl.spec.auto]

    1 Die auto und decltype(auto) Typ-Bezeichner bezeichnen einen Platzhalter
    Typ, wird später ausgetauscht, entweder durch Abzug von ein
    Initialisierung oder durch explizite Angabe mit einem trailing-return-Typ.
    Die auto Typ-Bezeichner wird auch verwendet, um anzuzeigen, dass ein lambda-Ausdruck ist ein
    generische lambda.

    2 Der Platzhalter Typ angezeigt werden können eine Funktion, mit der Feststellung in der decl-specifier-seq, type-specifier-seq,
    conversion-Funktion-id, oder trailing-return-Typ, in jedem Kontext, wo eine solche Feststellung ist gültig. Wenn die Funktion
    Feststellung enthält eine trailing-return-Typ (8.3.5), und gibt den deklarierten Rückgabetyp der Funktion.
    Wenn den deklarierten Rückgabetyp der Funktion enthält einen Platzhalter geben, der Rückgabetyp der Funktion ist
    abgeleitet von return-Anweisungen im Hauptteil der Funktion, falls vorhanden.

    Der Entwurf enthält auch dieses Beispiel von der Initialisierung der Variablen:

    int i;
int&& f();
auto x3a = i;                  //decltype(x3a) is int
decltype(auto) x3d = i;        //decltype(x3d) is int
auto x4a = (i);                //decltype(x4a) is int
decltype(auto) x4d = (i);      //decltype(x4d) is int&
auto x5a = f();                //decltype(x5a) is int
decltype(auto) x5d = f();      //decltype(x5d) is int&&
auto x6a = { 1, 2 };           //decltype(x6a) is std::initializer_list<int>
decltype(auto) x6d = { 1, 2 }; //error, { 1, 2 } is not an expression
auto *x7a = &i;                //decltype(x7a) is int*
decltype(auto)*x7d = &i;       //error, declared type is not plain decltype(auto)

    InformationsquelleAutor der Antwort TemplateRex

  2. 21

    Zitieren Sachen aus hier:

    • decltype(auto) ist in Erster Linie nützlich für Aufzucht der return-Typ von der Spedition Funktionen und ähnliche Wrapperwo Sie wollen, dass der Typ genau "verfolgen" einige Ausdruck Sie sind, aufrufen.

    • Zum Beispiel gegeben sind die folgenden Funktionen:

       string  lookup1();
   string& lookup2();
    • In C++11 konnten wir die folgenden schreiben wrapper-Funktionen, die daran erinnern, zu bewahren, die Referenz-ness der return-Typ:
       string  look_up_a_string_1() { return lookup1(); }
   string& look_up_a_string_2() { return lookup2(); }
    • In C++14, die wir automatisieren können, dass:
       decltype(auto) look_up_a_string_1() { return lookup1(); }
   decltype(auto) look_up_a_string_2() { return lookup2(); }

    • Jedoch decltype(auto) ist nicht vorgesehen, um eine weit verbreitete Funktion, die darüber hinaus.

    • Insbesondere, obwohl es kann verwendet werden, um lokale Variablen deklarieren,tun, dass ist wahrscheinlich nur ein antipattern, da eine lokale variable, die die Referenz-ness, sollte nicht davon abhängen, ob die Initialisierung Ausdruck.

    • Auch, es ist empfindlich, um, wie Sie schreiben, die return-Anweisung.

    • Zum Beispiel die beiden folgenden Funktionen haben unterschiedliche Rückgabe-Typen:

       decltype(auto) look_up_a_string_1() { auto str = lookup1(); return str; }
   decltype(auto) look_up_a_string_2() { auto str = lookup2(); return(str); }
    • Die ersten Erträge stringdie zweite gibt string&die einen Verweis auf die lokale variable str.

    Aus der Vorschlag Sie können sehen, weitere Verwendungszwecke.

    InformationsquelleAutor der Antwort 101010

Schreibe einen Kommentar