auto：编译器自动推导类型
auto是类型说明符，让编译器根据变量的初始化表达式自动推导类型，避免手写冗长的类型名（比如std::vector<int>::iterator、std::map<std::string, std::vector<int>>等）。
1. 推导时忽略引用属性
核心规则：当使用引用类型的变量初始化 auto 变量时，编译器只会推导引用指向对象的实际类型，不会继承引用属性。
易错点：比如定义int i = 10; int& ri = i;后，若写auto j = ri;，新手易误以为j的类型是int&，但实际j是int，引用属性被编译器直接忽略。
2. 忽略顶层 const，保留底层 const
核心规则：先明确两类 const 的区别 ——
- 顶层 const：修饰变量本身（如
const int ci = 42;、int* const p1 = &i;）； - 底层 const：修饰指针 / 引用指向的对象（如
const int* p2 = &ci;、const int& ri1 = ci;）。auto 推导类型时，会忽略初始化表达式的顶层 const 属性，但会完整保留底层 const 属性。
易错点：
const int ci = 42; auto r1 = ci;中，r1是int（顶层 const 被忽略）；const int* p2 = &ci; auto r3 = p2;中，r3是const int*（底层 const 保留）。
3. 需显式指定引用或顶层 const
核心规则：auto 本身无法自动推导引用类型或顶层 const 类型，若需要让 auto 变量具备这些特性，必须手动在 auto 后添加&（指定引用）或const（指定顶层 const）。易错点：
- 想要 auto 变量为引用类型，需写
auto& x = i;（此时x是int&）； - 想要 auto 变量带顶层 const，需写
const auto x = ci;（此时x是const int）。
4. auto& 绑定 const 对象时自动保留 const（避免权限放大）
核心规则：用auto&绑定带有 const 属性的对象时，编译器会自动为推导结果保留 const 限定符 —— 这是 C++ 的权限控制规则，因为若推导为非 const 引用，就可以通过该引用修改原本不可修改的 const 对象，属于 “权限放大”，编译器会直接报错。
易错点：const int ci = 42; auto& rx2 = ci;中，rx2会被推导为const int&，若强行认为rx2是int&并尝试执行rx2++，会触发编译报错；新手常不理解为何 auto& 绑定 const 对象会自动带 const，本质是为了避免权限违规。
5. auto&& 是万能引用（非单纯右值引用）
核心规则：auto&&遵循 “引用折叠” 规则，可绑定左值或右值：
- 初始化表达式是左值时，
auto&&推导为左值引用； - 初始化表达式是右值时，
auto&&推导为右值引用；且推导过程中会保留初始化对象的 const 属性。
易错点：
int x = 10; auto&& rx5 = x;中，x是左值，rx5推导为int&（左值引用）；auto&& rx7 = move(x);中，move(x)是右值，rx7推导为int&&（右值引用）；新手易将auto&&等同于普通右值引用，误以为它只能绑定右值
补充：顶层 const vs 底层 const
- 顶层 const：修饰变量本身（
const int ci=42;、int* const p1=&i;）；- 底层 const：修饰指针 / 引用指向的对象（
const int* p2=&ci;、const int& ri1=ci;）。
6. 代码示例
int x = 10; const int cx = 20; // 1. auto&：绑定左值，保留const auto& rx1 = x; // int&（非const，可修改） auto& rx2 = cx; // const int&（保留const，避免权限放大） func(rx1); // 调用 func(int&) func(rx2); // 调用 func(const int&) // 2. const auto&：可绑定左值/右值，始终const const auto& rx3 = x; // const int& const auto& rx4 = cx; // const int& func(rx3); // 调用 func(const int&) // 3. auto&& 万能引用（引用折叠） auto&& rx5 = x; // x是左值 → rx5是int& auto&& rx6 = cx; // cx是const左值 → rx6是const int& auto&& rx7 = move(x); // move(x)是右值 → rx7是int&& auto&& rx8 = move(cx);// move(cx)是const右值 → rx8是const int&& func(forward<int>(rx7)); // 转发为int&&，调用func(int&&) func(forward<const int>(rx8)); // 转发为const int&&，调用func(const int&&)运行结果：
plaintext
void func(int& x) void func(const int& x) void func(const int& x) void func(const int& x) void func(int& x) void func(const int& x) void func(int&& x) void func(const int&& x)7.补充
1. 非静态成员变量：完全不支持 auto 初始化
类内的非静态成员变量（每个对象独有的成员），不能用 auto 推导类型，哪怕就地初始化也会编译报错。
// C++11/C++14 编译报错！ class A { // 错误：C++11/14 不允许类内非静态成员用 auto 推导 auto x = 10; auto y = 3.14; };原因：C++11/14 中，auto的类型推导依赖「编译期能立即确定的初始化表达式」，但类的非静态成员变量的初始化时机是 “对象构造时”，编译器在解析类定义时，无法确定 auto 成员的具体类型（即使写了初始值，早期标准也未放开这个限制）。
2. 静态成员变量：类内声明不能用 auto，类外初始化可有限使用
静态成员变量（所有对象共享）的类内声明不能用 auto，但类外初始化时可以用 auto 推导类型 —— 但这种写法实用性极低，且易出错。
class B { // C++11/C++14 编译报错！类内静态成员声明不能用 auto // static auto s_val = 100; // 正确：类内声明必须指定明确类型 static int s_val; }; // 类外初始化：C++11/C++14 允许用 auto 推导 auto B::s_val = 100; // 推导为 int，等价于 int B::s_val = 100;注意：这种写法仅适用于「非模板类的静态成员」，模板类的静态成员仍无法用 auto 推导。
尾置返回类型：后置的函数返回类型声明
1. 核心作用
C++11 引入的函数声明语法，将返回类型放在参数列表后，解决「前置返回类型」的痛点：
- 复杂返回类型（如嵌套容器）可读性差；
- 模板函数返回类型依赖参数类型（前置语法无法推导）；
- Lambda 表达式必须用尾置语法声明返回类型。
2. 基本语法
auto 函数名(参数列表) -> 返回类型 { // 函数体 }场景 1：复杂返回类型（提升可读性）
// 前置写法（冗长，可读性差） std::map<std::string, std::vector<int>> getComplexType() { return {}; } // 尾置写法（更清晰） auto getComplexType() -> std::map<std::string, std::vector<int>> { return {}; }场景 2：模板函数返回类型依赖参数
// 尾置返回类型：用decltype推导t+u的类型 template <typename T, typename U> auto add(T t, U u) -> decltype(t + u) { return t + u; } // 调用：编译器自动推导返回类型（int+double→double） auto res = add(1, 2.5); // res是double场景 3：Lambda 表达式的返回类型
Lambda 表达式默认自动推导返回类型，但若逻辑复杂（如分支返回不同类型），需显式用尾置语法：
// 显式指定Lambda返回类型为double auto lambda = [](int x) -> double { if (x > 0) return x * 1.5; else return x * 2.0; };注意点
C++14 支持auto自动推导函数（包括模板函数）返回类型（无需尾置），但模板 / 复杂依赖场景仍需尾置返回类型。
decltype：推导表达式类型
decltype用于推导表达式的类型，但不执行表达式、也不需要用表达式初始化变量。
比如decltype(f()) x;：编译器仅推导f()的返回类型作为x的类型，不会实际调用f()。
易错点（对比 auto）
| 特性 | auto | decltype |
|---|---|---|
| 初始化要求 | 必须初始化（靠初始化表达式推导） | 无需初始化（靠表达式推导） |
| const 处理 | 忽略顶层 const，保留底层 const | 保留所有 const（顶层 + 底层） |
| 引用处理 | 忽略引用（需显式加 &） | 保留引用（无需显式加 &） |
| 特殊推导 | 无 | 1.decltype(*p)→ 引用类型；2.decltype((i))→ 引用类型 |
decltype(*p)：解引用表达式推导为引用类型（因为解引用本质是 “指向对象的别名”）；decltype((i))：括号包裹的左值表达式推导为引用类型（(i)是 “可赋值的表达式”，编译器视为引用）。
基础推导（对比 auto）
int i = 0; const int ci = 0; const int& rci = ci; int* p1 = &i; // auto推导（忽略顶层const/引用） auto a1 = ci; // int auto a2 = rci; // int auto a3 = p1; // int* // decltype推导（保留const/引用） decltype(ci) d1 = 1; // const int（保留顶层const） decltype(rci) d2 = d1; // const int&（保留引用+const） decltype(p1) d3 = nullptr; // int*（指针类型） // 特殊推导 decltype(*p1) d4 = i; // int&（解引用推导为引用） decltype((i)) d5 = i; // int&（括号包裹的左值推导为引用）易错点：
d1++编译报错（d1 是 const int）；d2++编译报错（d2 是 const int&）；decltype((i))是引用，必须初始化（引用不能空）。
解决 auto 无法使用的场景（类成员变量）
auto 不能用于类的非静态成员变量（因为类初始化阶段编译器无法推导），但 decltype 可以：
template <typename T> class A { public: void func(T& container) { _it = container.begin(); } private: // 错误：auto不能用于类成员变量 // auto _it; // 正确：用decltype推导container.begin()的类型 decltype(T().begin()) _it; }; // 调用：const vector<int>的begin()返回const_iterator，普通vector返回iterator const vector<int> v1; A<const vector<int>> obj1; // _it是const_iterator vector<int> v2; A<vector<int>> obj2; // _it是iterator模板函数返回类型依赖参数
前置返回类型无法推导参数相关的类型，需结合「尾置返回类型 + decltype」：
// 正确：auto做返回值占位，->decltype(*it1)推导返回类型 template<class Iter> auto Func(Iter it1, Iter it2) -> decltype(*it1) { auto& x = *it1; while (it1 != it2) { x += *it1; ++it1; } return x; } // 调用：推导vector<int>的元素类型int，list<string>的元素类型string vector<int> v = {1,2,3}; list<string> lt = {"111","222","333"}; auto ret1 = Func(v.begin(), v.end()); // int（值为6） auto ret2 = Func(lt.begin(), lt.end()); // string（值为"111222333"）注意：
decltype(*it1)推导的结果确实是引用类型（比如vector<int>::iterator解引用后，decltype(*it1)是int&；list<string>::iterator解引用后是string&），所以Func函数的返回类型本质是引用。
那为什么调用后ret1是int、ret2是string（值类型）？核心原因是：接收返回值的auto推导时忽略了引用属性（这正是我们之前讲过的 auto 推导规则 —— 用引用初始化 auto 变量时，推导结果是引用指向的对象类型，而非引用本身）。
decltype (auto)（C++14 新增）
结合auto的便利性和decltype的精确性，推导规则完全遵循 decltype：
int i = 0; const int ci = 42; int* const p1 = &i; // 顶层const（指针本身不可改） auto a = ci; // int（忽略顶层const） decltype(auto) d = ci; // const int（保留顶层const） auto b = p1; // int*（忽略顶层const） decltype(auto) e = p1; // int* const（保留顶层const）typedef 和 using：类型别名（C++11 using 增强）
两者都是重定义类型名（简化冗长类型书写），但 C++11 的using解决了typedef的核心痛点：支持模板别名。
2. 语法对比
| 功能 | typedef 语法 | using 语法 |
|---|---|---|
| 普通类型别名 | typedef 原类型 别名; | using 别名 = 原类型; |
| 函数指针别名 | typedef void (*Callback)(int); | using Callback = void (*)(int); |
| 模板别名 | 不支持 | template<class Val> using Map = map<string, Val>; |
3. 关键规则 & 示例解析
using 兼容 typedef 所有用法
// typedef 写法 typedef std::map<std::string, int> CountMap; typedef void (*Callback)(int); // 函数指针（typedef 写法不直观） // using 写法（更清晰，尤其是函数指针） using CountMap = std::map<std::string, int>; using Callback = void (*)(int);using 支持模板别名（typedef 不支持）
typedef 无法定义 “带模板参数的类型别名”，但 using 可以（核心增强）：
// 模板别名：Map<Val> = map<string, Val> template<class Val> using Map = std::map<std::string, Val>; // 模板别名：MapIter<Val> = map<string, Val>::iterator template<class Val> using MapIter = typename std::map<std::string, Val>::iterator; // 调用：自动推导Val类型 Map<int> countMap; // 等价于 map<string, int> Map<string> dictMap; // 等价于 map<string, string> MapIter<int> it = countMap.begin(); // 等价于 map<string, int>::iterator
