Semantica C++ 11 "auto"

Question

Quando uso C++ 11 auto, quali sono le regole di deduzione del tipo per quanto riguarda la risoluzione di un valore o un riferimento?

per esempio, a volte è chiaro:

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

Questi sono meno chiari:

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 regola è semplice: è come si dichiara.

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

esempio seguente dimostra:

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

L'output:

value 
reference 
value 
value 
reference 
value 

Answer 2

§7.1.6.4 [dcl.spec.auto] p6

volta che il tipo di un dichiaratore-id è stato determinare d secondo 8.3, il tipo della variabile dichiarata utilizzando l'identificatore viene determinato dal tipo del relativo inizializzatore utilizzando le regole per la deduzione degli argomenti del modello.

Questo significa nient'altro che la deduzione argomento modello modelli auto durante una chiamata di funzione.

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 che # 1 sarà sempre copiare l'argomento passato, non importa se si passa un riferimento o qualsiasi altra cosa. (A meno che non si specifichi specificatamente l'argomento modello come f<int&>(intref);.)

Answer 3

Qualsiasi cosa si ottenga dal lato destro (di "=") non è mai un riferimento. Più in particolare, il risultato di un'espressione non è mai un riferimento. In questa luce, nota la differenza tra i risultati nell'esempio.

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