it-swarm-pt.tech

Semântica "automática" do C ++ 11

Quando eu uso o C++ 11 auto, quais são as regras de dedução de tipo no que diz respeito à resolução de um valor ou referência?

Por exemplo, às vezes é claro:

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

Estes são menos claros:

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?
66
Alex B

A regra é simples: é como você a declara.

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

O próximo exemplo prova isso:

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

A saída:

value
reference
value
value
reference
value
82
BЈовић

§7.1.6.4 [dcl.spec.auto] p6

Depois que o tipo de um declarator-id for determinado de acordo com 8.3, o tipo da variável declarada usando o declarator-id é determinado a partir do tipo de seu inicializador usando o regras para dedução de argumento de modelo.

Isso significa apenas a dedução do argumento do modelo auto durante uma chamada de função.

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

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

Observe que o nº 1 sempre copiará o argumento passado, independentemente de você passar uma referência ou qualquer outra coisa. (A menos que você especifique especificamente o argumento do modelo como f<int&>(intref);.)

13
Xeo

O que você obtém do lado direito (de "=") nunca é uma referência. Mais especificamente, o resultado de uma expressão nunca é uma referência. Nesta luz, observe a diferença entre os resultados no exemplo.

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