Quand \"auto\" déduit-il une valeur ou une référence en C 11 ?

Comprendre la sémantique "auto" de C 11

En C 11, le mot-clé "auto" permet une déduction automatique de type. Cependant, déterminer s'il se résout en une valeur ou une référence peut parfois être ambigu.

Règles de déduction de type :

La règle de déduction de type dans "auto" est simple : il est basé sur la façon dont l'objet est déclaré.

Par exemple :

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

Si nous déclarons :

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

a1 sera déduit comme type de valeur (int), tandis que a2 sera déduit comme type de référence (int&).

Cas ambigus :

Considérez les exemples suivants :

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

get_foo renvoie une référence, mais p est déclaré comme "auto". Dans ce cas, auto déduira le type de p comme étant une référence à Foo.

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

s_foo est une instance statique d'un pointeur partagé vers Foo. sp est déclaré en utilisant "auto", il sera donc déduit comme un pointeur partagé vers Foo.

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

Ici, "auto" parcourra le vecteur, déduisant le type de foo comme étant un pointeur partagé à Foo. Cela signifie qu'un nouveau pointeur partagé temporaire est créé pour chaque itération.

Démonstration :

Le code suivant illustre ces concepts :

<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>

Sortie :

value
reference
value
value
reference
value

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!