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

Les subtilités de la sémantique "auto" C 11

En C 11, le mot-clé auto offre un moyen pratique de déduire automatiquement le type d'une variable en fonction de son initialiseur . Cependant, il y a certaines questions à considérer quant à savoir si auto sera résolu en une valeur ou une référence.

Comprendre la règle

La règle est simple : elle dépend de la façon dont la variable est déclarée.

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

🎜>

Dans le premier cas, a1 est une valeur car elle n'a pas été déclarée comme référence. Dans le deuxième cas, a2 est une référence car elle a été explicitement déclarée comme telle.

Clarification des incertitudes

Appliquons cette règle aux exemples que vous avez fournis :

• auto p = get_foo();
 : get_foo() renvoie une référence à un pointeur intelligent. Puisque p est déclaré sans référence, ce sera une copie, ce qui donnera un objet de type référence.
• auto sp = s_foo;
 : s_foo est une référence statique à un pointeur intelligent. Lors de son attribution à sp, la référence sera copiée, ce qui donnera un objet de type référence.
• for (auto foo: c)
 : foo sera une copie de chaque itérateur dans le vecteur car il n'est pas déclaré comme référence.

Preuve avec la métaprogrammation de modèles

Le code suivant démontre ce comportement à l'aide de la métaprogrammation de modèles :

<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&amp;>
{
    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

Cela confirme que le type d'auto est déterminé par sa déclaration, et non par le type de son initialiseur.

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!