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）decltype 推导函数类型
如何查看 decltype 推导的函数类型？
方法 1：typeid + name ()
用 typeid 获取类型信息，name() 输出类型名（不同编译器缩写不同）：
#include <iostream>
#include <typeinfo>
using namespace std;
int add(int a, int b) { return a + b; }
int main() {
using AddType = decltype(add); // 函数类型
using AddPtrType = decltype(&add); // 函数指针类型
// GCC输出：FiiE（函数类型）、PFiiE（函数指针类型）
// Clang输出：int (int, int)、int (*)(int, int)
cout << typeid(AddType).name() << endl;
cout << typeid(AddPtrType).name() << endl;
return 0;
}方法 3：static_assert + is_same（精准验证类型）
用 std::is_same 验证推导结果是否符合预期：
#include <iostream>
#include <type_traits>
using namespace std;
int add(int a, int b) { return a + b; }
int main() {
// 验证函数类型
static_assert(is_same_v<decltype(add), int(int, int)>,
"add的类型是int(int, int)");
// 验证函数指针类型
static_assert(is_same_v<decltype(&add), int(*)(int, int)>,
"&add的类型是int(*)(int, int)");
return 0;
}decltype 函数的规则（是否带 &？）
核心结论：decltype 推导函数名（不加 &）时，全局函数得「函数类型」（无 &、无 *），类成员函数直接报错；推导&函数名（加 &）时，全局 /static 成员函数得「普通函数指针」，普通成员函数得「成员函数指针」；所有推导结果永远不带 &。
全局函数（自由函数）
#include <iostream>
#include <type_traits>
using namespace std;
int add(int a, int b) { return a + b; }
int main() {
// 1. decltype(add) → 函数类型int(int, int)（抽象，仅可声明函数）
using FnType = decltype(add);
FnType f; // ✅ 合法：声明函数（等价于int f(int, int);）
f = add; // ✅ 函数名隐式转为函数指针赋值
// 2. decltype(&add) → 函数指针类型int(*)(int, int)（具体，可实例化）
using FnPtrType = decltype(&add);
FnPtrType fp = add; // ✅ 函数名隐式转指针
cout << fp(1,2) << endl; // 输出3
return 0;
}规则：
decltype(全局函数名)→ 函数类型（如int(int, int)），无 &、无 *；decltype(&全局函数名)→ 函数指针类型（如int(*)(int, int)），带 *；- 函数类型仅可声明函数，函数指针可定义变量、调用、传递。
类内普通成员函数
普通成员函数隐含this指针，仅能推导「成员函数指针类型」：
#include <iostream>
#include <type_traits>
using namespace std;
struct MyClass {
int func(int a) { return a * 2; }
};
int main() {
// 1. decltype(&MyClass::func) → 成员函数指针类型int (MyClass::*)(int)
using MemFnPtrType = decltype(&MyClass::func);
MemFnPtrType mfp = &MyClass::func; // ✅ 必须加&
// 调用：必须绑定类对象（.* 是成员指针调用符）
MyClass obj;
cout << (obj.*mfp)(3) << endl; // 输出6
// 2. decltype(MyClass::func) → 编译报错（无法直接推导）
// using MemFnType = decltype(MyClass::func);
return 0;
}规则：
decltype(&类名::普通成员函数)→ 成员函数指针类型（如int (MyClass::*)(int)），无 &、带类名::*；- 必须加 & 才能推导，调用时需绑定类对象（
obj.*mfp/ptr->*mfp）。
类内 static 成员函数
static 成员函数无this指针，推导结果为普通函数指针：
#include <iostream>
#include <type_traits>
using namespace std;
struct MyClass {
static int static_func(int a) { return a + 10; }
};
int main() {
// 1. decltype(&MyClass::static_func) → 普通函数指针类型int(*)(int)
using StaticFnPtrType = decltype(&MyClass::static_func);
StaticFnPtrType sfp = &MyClass::static_func;
cout << sfp(5) << endl; // 输出15（无需绑定类对象）
// 2. decltype(MyClass::static_func) → 编译报错
// using StaticFnType = decltype(MyClass::static_func);
return 0;
}规则：
decltype(&类名::static成员函数)→ 普通函数指针类型（如int(*)(int)），无 &、带 *；- 调用时无需绑定类对象，和全局函数指针用法一致。
函数类型 vs 函数指针类型
1. 核心定义
| 类型 | 核心定义 | 通俗比喻 |
|---|---|---|
| 函数类型 | 由「返回值 + 参数列表」构成的抽象类型，仅描述函数签名，无存储意义 | 身份证号规则（"18 位数字"）------ 描述格式，非具体身份证 |
| 函数指针类型 | 指向函数的指针类型，存储函数内存地址，可实例化的具体类型 | 具体身份证号（"110101199001011234"）------ 能唯一找到对应的人（函数） |
2. 维度对比
| 对比维度 | 函数类型（如int(int, int)） |
函数指针类型（如int(*)(int, int)） |
|---|---|---|
| 本质 | 抽象类型（仅描述签名） | 具体类型（存储内存地址） |
| 内存占用 | 无（抽象类型） | 有（32 位 4 字节 / 64 位 8 字节，同普通指针） |
| 定义变量 | ❌ 不可（无法实例化） | ✅ 可（存储函数地址） |
| 赋值规则 | 无法赋值 | 可赋值为函数名 /& 函数名（函数名隐式转指针） |
| 调用方式 | 无（无实例） | ✅ 可直接调用（fp(1,2)） |
| 语法形式 | 返回值 (参数列表) | 返回值 (*)(参数列表) |
| 模板场景 | 约束函数签名 | 传递具体函数（回调、函数表） |
3. 关键隐式转换
函数名出现在 "需要指针的场景" 时，会从函数类型隐式转为函数指针类型：
using FnType = int(int, int); // 函数类型
using FnPtrType = int(*)(int, int); // 函数指针类型
FnPtrType fp = add; // add（函数类型）→ 隐式转为函数指针类型
// 等价于 FnPtrType fp = &add;反过来，函数指针类型无法转换为函数类型（地址无法还原为抽象签名）。
4. 典型使用场景
| 类型 | 核心场景 |
|---|---|
| 函数类型 | 1. 模板参数约束（要求特定签名的函数）；2. 简化重复函数声明；3. 编译期类型检查（std::is_function） |
| 函数指针类型 | 1. 回调函数（如std::sort比较函数）；2. 动态选择函数（函数表）；3. 动态库函数调用（dlsym/GetProcAddress） |
5. 补充：类成员函数的特殊情况
-
普通成员函数的 "函数类型"：
int (MyClass::)(int)（抽象，无法直接用）； -
普通成员函数的 "指针类型"：
int (MyClass::*)(int)（具体，可实例化）； -
static 成员函数的指针类型 = 普通函数指针（无
this）。struct MyClass { int func(int a) { return a2; } };
// 成员函数指针类型（可实例化）
using MemFnPtrType = int (MyClass::)(int);
MemFnPtrType mfp = &MyClass::func; // ✅ 必须加&// 成员函数类型（抽象，无法实例化）
// using MemFnType = int (MyClass::)(int);
// MemFnType mf = &MyClass::func; // ❌ 编译错误
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