Placeholder type specifiers (since C++11)

Ein Platzhalter-Typspezifizierer bezeichnet einen Platzhaltertyp , der später ersetzt wird, typischerweise durch Ableitung von einem Initialisierer .

Syntax

Der Platzhalter auto kann von Modifikatoren begleitet werden, wie const oder & , die an der Typableitung teilnehmen werden. Der Platzhalter decltype ( auto ) muss der alleinige Bestandteil des deklarierten Typs sein. (seit C++14)

Erklärung

Ein Platzhalter-Typspezifizierer kann in den folgenden Kontexten erscheinen:

Funktionsdeklarationen

Ein Platzhaltertyp kann in den Deklarationsspezifizierern für einen Funktionsdeklarator erscheinen, der einen nachgestellten Rückgabetyp enthält.

auto f() -> int; // OK: f gibt int zurück
auto g() { return 0.0; } // OK seit C++14: g gibt double zurück
auto h(); // OK seit C++14: h's Rückgabetyp wird bei Definition abgeleitet

Variablendeklarationen

Der Typ einer Variable, die mit einem Platzhaltertyp deklariert wird, wird von ihrem Initialisierer abgeleitet. Diese Verwendung ist in einer initialisierenden Deklaration einer Variable zulässig.

Der Platzhaltertyp kann nur als einer der Deklarationsspezifizierer in der Deklarationsspezifizierer-Sequenz oder als einer der Typspezifizierer in einem nachgestellten Rückgabetyp auftreten, der den Typ angibt, der einen solchen Deklarationsspezifizierer ersetzt. In diesem Fall muss die Deklaration mindestens eine Variable deklarieren, und jede Variable muss einen nicht-leeren Initialisierer haben.

// "auto"s in Deklarationsspezifizierern
auto x = 5; // OK: x hat Typ int
const auto *v = &x, u = 6; // OK: v hat Typ const int*, u hat Typ const int
static auto y = 0.0; // OK: y hat Typ double
auto f() -> int;
auto (*fp)() -> auto = f; // OK: das "auto" im Trailing-Return-Type
                          // kann von f abgeleitet werden

new Ausdrücke

Ein Platzhaltertyp kann in der Typspezifizierer-Sequenz der Typ-ID eines new-Ausdrucks verwendet werden. In einer solchen Typ-ID muss der Platzhaltertyp als einer der Typspezifizierer in der Typspezifizierer-Sequenz oder als nachgestellter Rückgabetyp erscheinen, der den Typ angibt, der einen solchen Typspezifizierer ersetzt.

Hinweise

Bis C++11 hatte auto die Semantik eines storage duration specifier .

Ein Programm, das einen Platzhaltertyp in einem Kontext verwendet, der nicht explizit oben angegeben ist, ist fehlerhaft.

Falls eine Deklaration mehrere Entitäten deklariert und die Deklarationsspezifizierer-Sequenz einen Platzhaltertyp verwendet, ist das Programm fehlerhaft, wenn eine der folgenden Bedingungen erfüllt ist:

• Einige der deklarierten Entitäten sind keine Variablen.
• Der Typ, der den Platzhaltertyp ersetzt, ist nicht in jeder Deduktion derselbe.

auto f() -> int, i = 0; // Fehler: Deklariert eine Funktion und eine Variable mit "auto"
auto a = 5, b = {1, 2}; // Fehler: Unterschiedliche Typen für "auto"

Wenn eine Funktion oder Variable mit einem nicht ersetzten Platzhaltertyp durch einen Ausdruck referenziert wird, ist das Programm fehlerhaft.

auto v = 1;
auto l = [&]
{
    v++;
    return l;// Fehler: Der Platzhaltertyp für l wurde nicht ersetzt
};
std::function<void()> p = [&]
{
    v++;
    return p;// OK
};

Schlüsselwörter

auto , decltype

Beispiel

#include <iostream>
#include <utility>
template<class T, class U>
auto add(T t, U u) { return t + u; } // der Rückgabetyp ist der Typ von operator+(T, U)
// perfektes Weiterleiten eines Funktionsaufrufs muss decltype(auto) verwenden
// falls die aufgerufene Funktion eine Referenz zurückgibt
template<class F, class... Args>
decltype(auto) PerfectForward(F fun, Args&&... args) 
{ 
    return fun(std::forward<Args>(args)...); 
}
template<auto n> // C++17 auto Parameterdeklaration
auto f() -> std::pair<decltype(n), decltype(n)> // auto kann nicht aus Initialisierungsliste ableiten
{
    return {n, n};
}
int main()
{
    auto a = 1 + 2;          // Typ von a ist int
    auto b = add(1, 1.2);    // Typ von b ist double
    static_assert(std::is_same_v<decltype(a), int>);
    static_assert(std::is_same_v<decltype(b), double>);
    auto c0 = a;             // Typ von c0 ist int, enthält eine Kopie von a
    decltype(auto) c1 = a;   // Typ von c1 ist int, enthält eine Kopie von a
    decltype(auto) c2 = (a); // Typ von c2 ist int&, ein Alias von a
    std::cout << "before modification through c2, a = " << a << '\n';
    ++c2;
    std::cout << " after modification through c2, a = " << a << '\n';
    auto [v, w] = f<0>(); // strukturierte Bindungsdeklaration
    auto d = {1, 2}; // OK: Typ von d ist std::initializer_list<int>
    auto n = {5};    // OK: Typ von n ist std::initializer_list<int>
//  auto e{1, 2};    // Fehler seit DR n3922, davor std::initializer_list<int>
    auto m{5};       // OK: Typ von m ist int seit DR n3922, davor initializer_list<int>
//  decltype(auto) z = { 1, 2 } // Fehler: {1, 2} ist kein Ausdruck
    // auto wird häufig für unbenannte Typen wie Lambda-Ausdrücke verwendet
    auto lambda = [](int x) { return x + 3; };
//  auto int x; // gültig in C++98, Fehler ab C++11
//  auto x;     // gültig in C, Fehler in C++
    [](...){}(c0, c1, v, w, d, n, m, lambda); // unterdrückt "unused variable" Warnungen
}

before modification through c2, a = 3
 after modification through c2, a = 4

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

Referenzen