原文：http://blog.csdn.net/huang_xw/article/details/8760403

 C++11中引入的auto主要有兩種用途：自動型別推斷和返回值佔位。auto在C++98中的標識臨時變數的語義，由於使用極少且多餘，在C++11中已被刪除。前後兩個標準的auto，完全是兩個概念。

1. 自動型別推斷

1. #include <vector>
2. #include <map>
3. usingnamespace std;  
4. int main(int argc, char *argv[], char *env[])  
5. {  
6. //  auto a;                 // 錯誤，沒有初始化表示式，無法推斷出a的型別
7. //  auto int a = 10;        // 錯誤，auto臨時變數的語義在C++11中已不存在, 這是舊標準的用法。
8.     // 1. 自動幫助推導型別
9.     auto a = 10;  
10.     auto c = 'A';  
11.     auto s("hello");  
12.     // 2. 型別冗長
13.     map<int, map<
    int,int> > map_;  
14.     map<int, map<int,int>>::const_iterator itr1 = map_.begin();  
15.     const auto itr2 = map_.begin();  
16.     auto ptr = []()  
17.     {  
18.         std::cout << "hello world" << std::endl;  
19.     };  
20.     return 0;  
21. };  
22. // 3. 使用模板技術時，如果某個變數的型別依賴於模板引數，
23. // 不使用auto將很難確定變數的型別（使用auto後，將由編譯器自動進行確定）。
24. template <class T, class U>  
25. void Multiply(T t, U u)  
26. {  
27.     auto v = t * u;  
28. }  

2. 返回值佔位

1. template <typename T1, typename T2>  
2. auto compose(T1 t1, T2 t2) -> decltype(t1 + t2)  
3. {  
4.    return t1+t2;  
5. }  
6. auto v = compose(2, 3.14); // v's type is double

3.使用注意事項

1. auto k = 5;  
2. auto* pK = new auto(k);  
3. auto** ppK = new auto(&k);  
4. const auto n = 6;  

1. auto m; // m should be intialized  

1. auto int p; // 這是舊auto的做法。

1. void MyFunction(auto parameter){} // no auto as method argument
2. template<auto T> // utter nonsense - not allowed
3. void Fun(T t){}  

1. int* p = new auto(0); //fine
2. int* pp = new auto(); // should be initialized
3. auto x = new auto(); // Hmmm ... no intializer
4. auto* y = new auto(9); // Fine. Here y is a int*
5. auto z = new auto(9); //Fine. Here z is a int* (It is not just an int)

1. int value = 123;  
2. auto x2 = (auto)value; // no casting using auto
3. auto x3 = static_cast<auto>(value); // same as above 

1. auto x1 = 5, x2 = 5.0, x3='r';  // This is too much....we cannot combine like this

1. constint i = 99;  
2. auto j = i;       // j is int, rather than const int
3. j = 100           // Fine. As j is not constant
4. // Now let us try to have reference
5. auto& k = i;      // Now k is const int&
6. k = 100;          // Error. k is constant
7. // Similarly with volatile qualifer

1. int a[9];  
2. auto j = a;  
3. cout<<typeid(j).name()<<endl; // This will print int*
4. auto& k = a;  
5. cout<<typeid(k).name()<<endl; // This will print int [9]