C++11新特性之一：auto

C++是一門偉大的語言，永遠給程式員最大的設計自由， 未使用的特性從不産生副作用，新版本永遠完全相容舊版本。 C++11先前被稱作C++0x，即ISO/IEC 14882:2011，是C++程式設計語言的一個标準。

之前的C++标準包括C++98、C++03。 雖然此後的[C++14]才是C++的現行标準，但C++14旨在對C++11的小擴充（漏洞修複、功能改進），而C++11仍然是一個具有熱度的關鍵詞。

C++98 auto

早在C++98标準中就存在了auto關鍵字，那時的auto用于聲明變量為自動變量，自動變量意為擁有自動的生命期，這是多餘的，因為就算不使用auto聲明，變量依舊擁有自動的生命期：

int a =10 ;//擁有自動生命期
auto int b = 20 ;//擁有自動生命期
static int c = 30 ;//延長了生命期
           

C++98中的auto多餘且極少使用，C++11已經删除了這一用法，取而代之的是全新的auto：變量的自動類型推斷。

C++11 auto

auto可以在聲明變量的時候根據變量初始值的類型自動為此變量選擇比對的類型，類似的關鍵字還有decltype。舉個例子：

auto a = 10;
auto *pa = new auto(a);
auto **rpa = new auto(&a);
cout << typeid(a).name() << endl;   //輸出：int
cout << typeid(pa).name() << endl;  //輸出：int *
cout << typeid(rpa).name() << endl; //輸出：int **
           

typeid運算符可以輸出變量的類型。

這種用法就類似于C#中的var關鍵字。auto的自動類型推斷發生在編譯期，是以使用auto并不會造成程式運作時效率的降低。而是否會造成編譯期的時間消耗，我認為是不會的，在未使用auto時，編譯器也需要得知右操作數的類型，再與左操作數的類型進行比較，檢查是否可以發生相應的轉化，是否需要進行隐式類型轉換。

auto的用法

上面舉的這個例子很簡單，在真正程式設計的時候也不建議這樣來使用auto，直接寫出變量的類型更加清晰易懂。下面列舉auto關鍵字的正确用法。

用于代替冗長複雜、變量使用範圍專一的變量聲明

想象一下在沒有auto的時候，我們操作标準庫時經常需要這樣：

#include<string>
#include<vector>
int main()
{
    std::vector<std::string> vs;
    for (std::vector<std::string>::iterator i = vs.begin(); i != vs.end(); i++)
    {
        //...
    }
}
           

這樣看代碼寫代碼實在煩得很。有人可能會說為何不直接使用using namespace std，這樣代碼可以短一點。實際上這不是該建議的方法（C++Primer對此有相關叙述）。使用auto能簡化代碼：

#include<string>
#include<vector>
int main()
{
    std::vector<std::string> vs;
    for (auto i = vs.begin(); i != vs.end(); i++)
    {
        //..
    }
}
           

for循環中的i将在編譯時自動推導其類型，而不用我們顯式去定義那長長的一串。

在定義模闆函數時，用于聲明依賴模闆參數的變量類型

#include <iostream>
#include <vector>
using namespace std;

template<class T, class U>
void add(T t, U u)
{
     auto s = t + u;
     cout << typeid(s).name() << endl;//輸出：double
}

int main()
{
     // 使用模闆技術時，如果某個變量的類型依賴于模闆參數，使用auto确定變量類型
     add(101, 1.1);

     system("pause");
     return 0;
}
           

若不使用auto變量來聲明s，那這個函數就難定義啦，不到編譯的時候，誰知道x*y的真正類型是什麼呢？

函數傳回占位符

在這種情況下，auto主要與decltype關鍵字配合使用，作為傳回值類型後置時的占位符。此時，關鍵字不表示自動類型檢測，僅僅是表示後置傳回值的文法的一部分。

template<class T, class U>
auto add(T t, U u) -> decltype(t + u) 
{
    return t + u;
}
           

auto在這裡的作用也稱為傳回值占位，它隻是為函數傳回值占了一個位置，真正的傳回值是後面的decltype(t + u)。為何要将傳回值後置呢？如果沒有後置，則函數聲明時為：

template<class T, class U>
decltype((*(T*)0) + (*(U*)0)) add(T t, U u)
{
    return t + u;
}
           

此時雖然能實作相同的功能，但是代碼編寫要醜陋得多。

注意事項

1.auto 變量必須在定義時初始化，這類似于const關鍵字

定義在一個auto序列的變量必須始終推導成同一類型。例如：

auto a4 = 10, a5 = 20, a6 = 30;//正确
auto b4 = 10, b5 = 20.0, b6 = 'a';//錯誤,沒有推導為同一類型
           

2.如果初始化表達式是引用，則去除引用語義

int a = 10;
int &b = a;

auto c = b;//c的類型為int而非int&（去除引用）
auto &d = b;//此時c的類型才為int&

c = 100;//a =10;
d = 100;//a =100;
           

3.如果初始化表達式為const或volatile（或者兩者兼有），則除去const/volatile語義

const int a1 = 10;
auto  b1= a1; //b1的類型為int而非const int（去除const）
const auto c1 = a1;//此時c1的類型為const int
b1 = 100;//合法
c1 = 100;//非法
           

4.如果auto關鍵字帶上&号，則不去除const語意

const int a2 = 10;
auto &b2 = a2;//因為auto帶上&，故不去除const，b2類型為const int
b2 = 10; //非法
           

這是因為如何去掉了const，則b2為a2的非const引用，通過b2可以改變a2的值，則顯然是不合理的。

5.初始化表達式為數組時，auto關鍵字推導類型為指針

int a3[3] = { 1, 2, 3 };
auto b3 = a3;
cout << typeid(b3).name() << endl;//輸出int*
           

6.若表達式為數組且auto帶上&，則推導類型為數組類型

int a7[3] = { 1, 2, 3 };
auto & b7 = a7;
cout << typeid(b7).name() << endl;//輸出為int[3]
           

7.函數或者模闆參數不能被聲明為auto

void func(auto a)  //錯誤
{
     //... 
}
           

8.時刻要注意auto并不是一個真正的類型

auto僅僅是一個占位符，它并不是一個真正的類型，不能使用一些以類型為操作數的操作符，如sizeof或者typeid。

cout << sizeof(auto) << endl;//錯誤
cout << typeid(auto).name() << endl;//錯誤
           

參考連結： https://www.cnblogs.com/QG-whz/p/4951177.html