理解auto型別推斷

上一篇帖子中講述了模板型別推斷，我們知道auto的實現原理是基於模板型別推斷的，回顧一下模板型別推斷：

template <typename T>
void f(ParamType param);

使用下面的函式呼叫：

f(expr);

我們看到模板型別推斷過程涉及到了模板template、函式f以及引數(包括模板引數和函式引數)，呼叫f的時候，編譯器會推斷T和ParamType的型別。auto的實現和這三個部分是有著對應關係的。當使用auto宣告一個變數，auto關鍵字扮演的是模板型別推斷中T的角色,而型別說明符扮演的是ParamType的角色。看下面的例子：

auto x = 27;  //型別說明符就是auto自己
const auto cx =x; //型別說明符為const auto
const auto& rx =x;//型別說明符為const auto&

編譯器使用auto對上面的型別進行推斷就如同使用了下面的模板型別推斷：

template<typename T> 
void func_for_x(T param); //ParamType即非引用也非指標
func_for_x(27); // 推斷x的型別，T為int ,ParamType 為 int

template<typename T> 
void
 
 func_for_cx(const T param); //ParamType即非引用也非指標
func_for_cx(x); //用於推斷cx的型別,T為int，ParamType為 const int

template<typename T> 
void func_for_rx(const T& param);//ParamType為引用
func_for_rx(x); // 用於推斷rx的型別,T為int,ParamType為const int&

繼續回顧上一篇帖子的內容，基於ParamType的三種形式，模板型別推斷也對應著三種不同情況。而auto的型別說明符扮演的是ParamType，因此使用auto進行變數宣告，也會有三種情況：

• 型別說明符是指標或者引用型別，但不是universal reference
• 型別說明符是universal reference。
• 型別說明符即非指標也非引用。

上面舉的例子是第一種和第三種情況：

auto x = 27; //case 3 x型別被推斷為int
const auto cx = x; //case 3  cx被推斷為 const int
const auto &rx = x; //case 1 rx被推斷為const int &

舉一個情況2的例子：

auto&& uref1 = x; //x為左值，uref1被推斷為左值引用
auto&& uref2 = cx; // cx  const int 左值，uref2被推斷為const int &
auto&& uref3 = 27; // 27 為 int 右值，uref3被推斷為 int &&

上篇帖子介紹了對於模板中的非引用ParamType,傳入函式或者陣列實參的時候會退化為指標的情況（而使用引用ParamType的時候，陣列實參會被推斷為指向陣列的引用），auto型別推斷也會如此：

const char name[] =  "R. N. Briggs";
auto arr1 = name; // arr1 的型別為const char*
auto& arr2 = name; // arr2 的型別為const char (&)[13]
void someFunc(int, double); 
auto func1 = someFunc; // func1的 型別為 void (*)(int, double)
auto& func2 = someFunc; // func2的型別為 void (&)(int, double)

上面介紹的都是auto和模板型別推斷使用原理相同的部分，下面說的不一樣的。

C++98中初始化一個Int有兩種方式：

int x1=27;
int x1(27);

在C++11中，支援統一初始化（uniform initialization）:

int x3 = {27};
int x3{27};

四種語法形式的結果只有一個，初始化一個Int值為27。這裡我們將都使用auto進行初始化：

auto x1 = 27;
 auto x2(27);
 auto x3 = {27};
 auto x4{27}; 

上面的四句話都能編譯通過，但並沒有和原來的四種形式意義完全一致。前面兩個是一樣的，後面兩句話宣告的變數型別是std::initializer_list,其中包含了單個元素，值為27。

 auto x1 = 27; //x1為int，值為27
 auto x2(27);//同上
 auto x3 = {27};//x3為 std::initializer_list<int>,值為{27}
 auto x4{27}; //同上

這裡就用到了一個對於auto的特殊型別推斷規則：當用大括號括起來的值對auto變數進行初始化的時候（叫做統一初始化式），變數型別會被推斷為 std::initializer_list。如果不能夠推斷成此型別（比如，大括號中的值不是同一型別），編譯會出錯：

auto x5 = { 1, 2, 3.0 }; // error! 型別不一致，不能將推斷為std::initializer_list<T>

這裡會發生兩種型別推斷，一種是將統一初始化式推斷為std::initializer_list ，而std::initializer_list本身也是一個型別為T的模板，因此會根據統一初始化式中的實參對T進行模板型別推斷，這是第二種型別推斷。上面的型別推斷會失敗是因為第二種型別推斷會失敗。

對統一初始化式的處理的不一致是auto和模板型別推斷的唯一區別。使用統一初始化式對auto變數初始化會將其推斷為std::initializer_list，但是模板型別推斷不會這麼做：

auto x = { 11, 23, 9 }; // x的型別為 std::initializer_list<int>

template<typename T> // 和auto x等同的模板型別推斷
void f(T param); 

f({ 11, 23, 9 }); // 錯誤！這裡不能推斷T的型別。

如果要達到auto的效果，得按照下面的方式來做：

template<typename T>
void f(std::initializer_list<T> initList);
f({ 11, 23, 9 }); // T被推斷為int, initList 的型別為 std::initializer_list<int>

在C++11中使用auto時，這裡比較容易出錯，你本來想宣告別的變數，最終卻將其宣告成了一個 std::initializer_list。因此，要謹慎使用統一初始化。

在C++14中，允許將auto作為函式返回值，也可以用其修飾lambda表示式中的引數。但是這些auto使用的都是模板型別推斷，而不是auto型別推斷，因此一個函式返回值為auto 型別時，返回統一初始化式的值會出錯：

auto createInitList()
{
    return { 1, 2, 3 }; // 錯誤！不能推斷{1，2，3}
}

下面的方式是對的：

std::initializer_list<int> createInitList()
{
    return { 1, 2, 3 }; // 
}

最後總結一下：

• 模板型別推斷是auto的基礎，auto關鍵字扮演了模板型別推斷中的T，而型別說明符扮演的是ParamType。
• 對於模板型別推斷和auto型別推斷，大多數場景下推斷規則相通，有一種特殊情況，就是統一初始化式。
• C++14中使用auto可以作為函式返回值，也可以作為lambda表示式的引數修飾符，但需要注意，這裡的auto使用的是模板型別推斷，而不是auto型別推斷。

轉自：https://www.cnblogs.com/harlanc/p/10628321.html