Wann leitet „auto' in C 11 einen Wert oder eine Referenz ab?

Die „auto“-Semantik von C 11 verstehen

In C 11 ermöglicht das Schlüsselwort „auto“ die automatische Typableitung. Die Bestimmung, ob es sich um einen Wert oder eine Referenz handelt, kann jedoch manchmal nicht eindeutig sein.

Typabzugsregeln:

Die Regel für den Typabzug in „auto“ ist unkompliziert : Es basiert darauf, wie das Objekt deklariert wird.

Zum Beispiel:

<code class="cpp">int i = 5;</code>

Wenn wir deklarieren:

<code class="cpp">auto a1 = i;    // value
auto &a2 = i;  // reference</code>

a1 wird als Werttyp abgezogen (int), während a2 als Referenztyp (int&) abgezogen wird.

Mehrdeutige Fälle:

Betrachten Sie die folgenden Beispiele:

<code class="cpp">const std::shared_ptr<Foo>& get_foo();
auto p = get_foo(); // Copy or reference?</code>

get_foo gibt eine Referenz zurück, aber p ist als „auto“ deklariert. In diesem Fall leitet auto ab, dass der Typ von p eine Referenz auf Foo ist.

<code class="cpp">static std::shared_ptr<Foo> s_foo;
auto sp = s_foo; // Copy or reference?</code>

s_foo ist eine statische Instanz eines gemeinsamen Zeigers auf Foo. sp wird mit „auto“ deklariert, sodass es als gemeinsamer Zeiger auf Foo abgezogen wird.

<code class="cpp">std::vector<std::shared_ptr<Foo>> c;
for (auto foo: c) { // Copy for every loop iteration?</code>

Hier iteriert „auto“ durch den Vektor und leitet daraus ab, dass es sich bei foo um einen gemeinsam genutzten Zeiger handelt zu Foo. Dies bedeutet, dass für jede Iteration ein neuer temporärer gemeinsam genutzter Zeiger erstellt wird.

Demonstration:

Der folgende Code demonstriert diese Konzepte:

<code class="cpp">#include <typeinfo>
#include <iostream>

template< typename T >
struct A
{
    static void foo(){ std::cout << "value" << std::endl; }
};
template< typename T >
struct A< T&& >
{
    static void foo(){ std::cout << "reference" << std::endl; }
};

float& bar()
{
    static float t=5.5;
    return t;
}

int main()
{
    int i = 5;
    int &r = i;

    auto a1 = i;
    auto a2 = r;
    auto a3 = bar();

    A<decltype(i)>::foo();       // value
    A<decltype(r)>::foo();       // reference
    A<decltype(a1)>::foo();      // value
    A<decltype(a2)>::foo();      // value
    A<decltype(bar())>::foo();   // reference
    A<decltype(a3)>::foo();      // value
}</code>

Ausgabe:

value
reference
value
value
reference
value

Das obige ist der detaillierte Inhalt vonWann leitet „auto' in C 11 einen Wert oder eine Referenz ab?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!