Понятия не имею о выводе типа C ++ 11

Question

Не имею представления о выводе типа C ++ 11

Как я знаю, в C ++ 11 есть как минимум 3 вывода типа:

• шаблон выводит
• auto
• decltype

Но я не могу построить для них концептуальную модель.Меня это смущает.
Это приводит к тому, что я не знаю, что правильно в тонком случае.

На самом деле, я даже не знаю, какой у меня вопрос.Но я пытаюсь:

Я хочу знать, как квалификаторы cv, & и && влияют на вывод типа.
Я хочу знать, в чем разница между тремя типами вывода типа.

///The following extract from 14.8.2.1 in n3242
template <class T> int f(T&&);
template <class T> int g(const T&&);
int i;
int n1 = f(i); // calls f<int&>(int&)
int n2 = f(0); // calls f<int>(int&&)
int n3 = g(i); // error: would call g<int>(const int&&), which
// would bind an rvalue reference to an lvalue

///The following extract from 8.3.2 in n3242
int i;
typedef int& LRI;
typedef int&& RRI;
LRI& r1 = i; // r1 has the type int&
const LRI& r2 = i; // r2 has the type int&
const LRI&& r3 = i; // r3 has the type int&
RRI& r4 = i; // r4 has the type int&
/*The following statement encounter compilation error in gcc 4.6:error message:
invalid initialization of reference of type int&& from expression of type int*/
RRI&& r5 = i; // r5 has the type int&&
decltype(r2)& r6 = i; // r6 has the type int&
decltype(r2)&& r7 = i; // r7 has the type int&

///The following is from some blog
int i;
decltype( i ) ==> int
decltype( (i) ) ==> int &

Answer 1

Шаблон вычета в C ++ 03

template <typename T> void foo(T) {}
int i;
float f;
foo (i); // deduces foo<int>
foo (f); // deduces foo<float>

Здесь компилятор видит foo(i) и говорит себе: «T часть foo должна быть int, чтобы соответствовать».

auto довольно просто.

int foo ();
float bar ();
auto i = foo (); // i is an int
auto f = bar (); // f is a float

Компилятор видит auto i = и говорит самому себе: «Правая сторона даёт int, поэтому i должен быть одним из них».

decltype немного сложнее, своего рода мета-авто. decltype(x) эквивалентно int, если x - int, float, если x - float и т. Д. Преимущество заключается в том, что вы можете использовать его в выражениях шаблонов.

int foo (float);
float foo (int);

template <typename T> void convert (std :: vector <T> input) {
    std :: vector <decltype (foo(input[0]))> output;
    output .push_back (foo (input [0])); // yeah, ok, not safe, meh
}

convert (std :: vector <int> ());   // Will create an output of type std::vector<float>
convert (std :: vector <float> ()); // Will create an output of type std::vector<int>

Здесь decltype (foo(input[0])) - это float, когда input - это вектор int, поскольку input[0] - это int, а перегрузка foo, которая принимает int, возвращает float.