C++ 11 semántica "automática"

Question

Cuando uso C++ 11 auto, ¿cuáles son las reglas de tipo de deducción con respecto a si se resolverá con un valor o una referencia?

por ejemplo, a veces es clara:

auto i = v.begin(); // Copy, begin() returns an iterator by value 

Estos son menos claras:

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

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

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

Answer 1

La regla es simple: es la forma en que se declara.

int i = 5; 
auto a1 = i; // value 
auto & a2 = i; // reference 

Siguiente ejemplo demuestra que:

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

La salida:

value 
reference 
value 
value 
reference 
value 

Answer 2

§7.1.6.4 [dcl.spec.auto] p6

Una vez que el tipo de un declarador-id ha sido determinar d de acuerdo con 8.3, el tipo de la variable declarada que utiliza el declarator-id se determina a partir del tipo de su inicializador usando las reglas para la deducción del argumento de la plantilla.

Esto significa nada más que auto modelos de argumento de deducción de la plantilla durante una llamada a la función.

template<class T> 
void f(T){} // #1, will also be by-value 

template<class T> 
void g(T&){} // #2, will always be by-reference 

Nota # 1 que siempre habrá copiar el argumento pasado, no importa si se pasa una referencia o cualquier otra cosa. (A menos que especifique específicamente el argumento de la plantilla como f<int&>(intref);.)

Answer 3

Lo que obtenga del lado derecho (de "=") nunca es una referencia. Más específicamente, el resultado de una expresión nunca es una referencia. En esta luz, observe la diferencia entre los resultados en el ejemplo.

#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() 
{ 
    auto a3 = bar(); 

    A<decltype(bar())>::foo(); // reference 
    A<decltype(a3)>::foo(); // value 
}