自動類型推導(dǎo)
現(xiàn)代的編程語言落蝙，不管是動態(tài)語言（JavaScript胰锌、Python 等）衩茸，還是靜態(tài)語言（Go芹血、Rust 等），大都支持自動類型推導(dǎo)（type deduction）。
自動類型推導(dǎo)幔烛，通俗地講就是定義一個變量的時候不需要明確指定類型啃擦，而是讓編譯器根據(jù)上下文進(jìn)行推導(dǎo)。
在 C++11 之前饿悬，模板（template）代碼就支持編譯器自動類型推導(dǎo)令蛉。C++11 很重要的一個特性就是加強(qiáng)了編譯器自動類型推導(dǎo)的能力，使之不限于模板 —— 與此相關(guān)的關(guān)鍵字有兩個 auto 和 decltype 乡恕。
auto
我們來看看 auto 關(guān)鍵字在 C++ 中的使用言询。
最簡單的用法，定義變量的時候不指定類型傲宜，通過初始化的值讓編譯器自動推導(dǎo)运杭。
auto a; // 編譯不通過
auto b = 0; // b 是 int 類型
auto c = 0ull; // c 是 unsigned long long 類型
auto d = "Hello World"; // d 是 const char* 類型
auto e = std::string("Hello"); // e 是 std::string 類型
auto 和容器類型、迭代器一起配合使用函卒，可以少打很多字辆憔，代碼也更簡潔、清晰报嵌。
std::vector<int> v(10, 1);
auto itr_begin = v.begin(); // std::vector<int>::iterator
auto itr_end = v.end(); // std::vector<int>::iterator
auto sz = v.size(); // std::vector<int>::size_type
如果不用自動類型推導(dǎo)虱咧，下面 v 的類型寫起來也很麻煩。如果 b 和 e 是自定義的迭代器锚国，不一定能用 typename std::iterator_traits<Iter>::value_type 來獲得類型腕巡。
template<typename Iter>
void Process(Iter b, Iter e) {
while (b != e) {
auto v = *b; // 如果不用自動類型推導(dǎo)，如何獲得 *b 的類型
// typename std::iterator_traits<Iter>::value_type v = *b;
std::cout << v << std::endl;
++b;
}
}
類型推導(dǎo)可以和 Lambda 表達(dá)式一起愉快地使用血筑。
auto Plus = [](int a, int b) { return a + b; };
也許有人會說绘沉，Lambda 表達(dá)式可以用一個 std::function<T> 對象來包裝。
std::function<int(int, int)> PlusFunc = [](int a, int b) { return a + b; };
但是這樣做有幾點不好：
- std::function<T> 內(nèi)部會涉及動態(tài)內(nèi)存分配豺总，性能上劣于自動類型推導(dǎo)的實現(xiàn)车伞；
- 讓代碼看起來復(fù)雜不少；
- 對于泛型 Lambda 表達(dá)式喻喳，std::function<T> 也無能為力了另玖。
auto Plus = [](auto a, auto b) { return a + b; }; // std::function<T> 的類型沒法寫了
std::cout << Plus(3, 4) << std::endl;
std::cout << Plus(3.14, 1.11) << std::endl;
std::cout << Plus(std::string("hello"), std::string("world")) << std::endl;
某些情況下，自動類型推導(dǎo)還可以讓你避免一些“坑”表伦。比如：
std::unordered_map<std::string, int> m;
// ...
for (const std::pair<std::string, int>& pa : m) { // 你覺得有沒有問題谦去？
// ...
}
看得出上面這段代碼有什么問題嗎？<br />上面的代碼會導(dǎo)致復(fù)制整個 unordered_map蹦哼。因為 std::unordered_map<Key, T>::value_type 的類型是 std::pair<const Key, T>哪轿。正確的寫法應(yīng)該是：
for (const std::pair<const std::string, Foo>& pa : m) {
// ...
}
用自動類型推導(dǎo)可以簡單避免這個坑：
for (const auto& pa : m) {
// ...
}
當(dāng)然，用自動類型推導(dǎo)的時候翔怎，也可能引入一些坑窃诉。比如：
std::vector<bool> v2;
v2.push_back(true);
v2.push_back(false);
auto b2 = v2[0]; // b2 是什么類型杨耙？
因為 std::vector<bool> 的特殊實現(xiàn)原因，變量 b2 不是一個 bool 類型飘痛，而是一個自定義的類珊膜。（無論你是否使用自動類型推導(dǎo)，都盡可能不要使用 std::vector<bool>宣脉。）
decltype
decltype 的作用是车柠，告訴你一個表達(dá)式/變量/常量是什么類型。比如：
std::cout << typeid(decltype(1)).name() << std::endl; // 輸出 i塑猖，表示 int
float f;
std::cout << typeid(decltype(f)).name() << std::endl; // 輸出 f竹祷，表示 float
unsigned a = 1;
unsigned long long b = 2;
std::cout << typeid(decltype(a + b)).name() << std::endl; // 輸出 y，表示 unsigned long long
typeid(T).name() 在不同的編譯器下的輸出可能不一樣羊苟。本文在 Ubuntu 上使用 gcc 7.5 進(jìn)行編譯塑陵。typeid(T).name() 的輸出可以通過 c++filt 工具轉(zhuǎn)換成實際可讀的類型名稱。
相比 auto蜡励，decltype 用得少很多令花。
舉一個例子：
template<typename T, typename U>
??? Plus(T t, U u)
return t + u;
}
t + u 到底應(yīng)該返回什么類型？
Plus(1, 2); // 返回值類型應(yīng)該是 int
Plus(1, 2.0); // 返回值類型應(yīng)該是 double
使用 decltype 的 trailing return type 來解決這個問題：
template<typename T, typename U>
auto Plus(T t, U u) -> decltype(t + u) {
return t + u;
}
C++ 14 進(jìn)行了加強(qiáng)凉倚，可以省掉這條尾巴兼都。
template<typename T, typename U>
auto Plus(T t, U u) {
return t + u;
}
如果函數(shù)有多個 return 語句，需要保證它們返回的類型都是一樣的才能成功編譯稽寒。
// error: inconsistent deduction for auto return type: ‘int’ and then ‘double’
auto f(int i) {
if (i == 1) {
return 1;
} else {
return 2.0;
}
}
decltype(auto)
使用 auto 需要自己手動說明是值類型還是引用類型扮碧。C++14 引入 decltype(auto) 來自動推導(dǎo)精確類型——其實 decltype(auto) 算是 decltype(expr) 的一個語法糖。
std::vector<std::string> v{"C++98", "C++03", "C++11",
"C++14", "C++17", "C++20"};
// v[0] 的返回值類型是 std::string&杏糙，但是 a 是 std::string
auto a = v[0];
// a 是 std::string&
auto& b = v[0];
// C++11慎王，我們可以這樣確定精確類型，c 是 std::string&
// 但是搔啊，如果 v[0] 變成一個復(fù)雜的表達(dá)式，代碼寫出來可能很難看懂
decltype(v[0]) c = v[0];
// C++14 引入了 decltype(auto)北戏，可以自動推導(dǎo)出精確類型负芋。d 是 std::string&
decltype(auto) d = v[0];
