[C++高频精进] 现代C++特性：自动推导

核心要点速览

• auto：基础推导忽略顶层 const / 引用，C++14 拓展至函数返回值与 lambda 参数，有明确使用限制。
• decltype：精确保留类型（含 const / 引用），支持表达式推导，双层括号是推导左值引用的关键。
• 模板类型推导：分按值 / 按引用 / 万能引用三类场景，需特殊处理数组与函数名，核心是 “实参到形参的类型映射”。
• 进阶场景：decltype(auto) 结合两者优势，auto&& 适配多值类别，万能引用需搭配 std::forward 实现完美转发。
• 区别：auto 侧重 “简化声明”，decltype 侧重 “精确获取”，模板推导侧重 “参数适配”。

一、auto：自动推导变量类型

用途是简化长类型声明，C++14 拓展了适用场景，推导逻辑聚焦 “忽略顶层修饰，保留底层约束”。

1. 推导规则

• 必须初始化：编译器依赖初始化表达式推导，未初始化编译报错（如auto x;报错）。
• 顶层 const / 引用忽略：变量本身的 const 和引用被舍弃，底层 const（指向常量的约束）保留。
  • 示例：const int x=10; auto a=x;（a 为 int）；int& ref=x; auto c=ref;（c 为 int）；const int* p=&x; auto e=p;（e 为const int*）。
• 显式保留修饰：需保留引用 /const 时，添加&或const，如auto& b=x;（b 为const int&）、const auto f=x;（f 为const int）。

2. C++14 拓展规则

• 函数返回值推导：所有 return 语句类型需一致，不可用于递归函数。
  • 示例：auto add(int a, int b) { return a + b; }（推导为 int）。
• 泛型 lambda：lambda 参数可声明为 auto，支持多类型调用。
  • 示例：auto sum = [](auto a, auto b) { return a + b; };（兼容 int、double 等）。

3. 限制

• 不用于函数参数：void func(auto x)（C++17 后支持但不推荐，易与模板混淆）。
• 不用于非静态成员变量：类成员初始化时机与 auto 推导冲突。
• 不推导数组类型：int arr[5]; auto p=arr;（p 为int*，需保留数组类型用auto(&p)[5] = arr;）。

二、decltype：推导表达式精确类型

优势是 “完全保留原始类型”，无需执行表达式，适配需精确类型的场景。

1. 推导规则

• 推导变量名：结果为变量声明类型（完全保留 const 和引用）。
  • 示例：const int& ref=x; decltype(ref) r=ref;（r 为const int&）。
  • 双层括号规则：变量名加双层括号时，推导为左值引用（(x)是左值表达式）。
    • 示例：int x=10; decltype(x) a=x;（a 为 int）；decltype((x)) b=x;（b 为int&，需初始化）。
• 推导表达式：根据值类别判断，左值表达式推导为引用，右值表达式推导为非引用。
  • 示例：int x=0; decltype(x++) a=x;（x++ 是右值，a 为 int）；decltype(++x) b=x;（++x 是左值，b 为int&）。
• 推导函数调用：结果为函数返回类型（不执行函数，需声明可见）。
  • 示例：int func(int); decltype(func(3)) c=0;（c 为 int）。

2. 用途

• 模板返回值推导：避免类型丢失，C++11 需尾置返回值，C++14 可省略。
  • 示例：template<typename T, typename U> auto add(T a, U b) -> decltype(a+b) { return a+b; }。
• 简化复杂类型声明：如std::map<int, std::string> m; decltype(m.begin()) it = m.begin();。

三、auto 与 decltype 区别

对比维度	auto	decltype
推导依据	变量初始化表达式的类型	任意表达式 / 变量名的类型（不执行表达式）
const / 引用处理	忽略顶层 const 和引用，保留底层 const	完全保留 const 和引用（含表达式值类别）
初始化要求	必须初始化	无需初始化（推导表达式类型时）
C++ 版本拓展	C++14 支持函数返回值、lambda 参数	C++11 起稳定，无重大拓展
进阶场景	可结合&&实现auto&&	可结合auto实现decltype(auto)

四、模板类型推导

模板参数 T 的推导规则与 auto 类似，分三类场景，需处理特殊类型（数组 / 函数名）。

1. 按值传递（模板参数为 T）

• 规则：忽略实参的顶层 const 和引用，保留底层 const。
  • 示例：template<typename T> void func(T x);
    • const int a=10; func(a);（T 为 int）；int& b=x; func(b);（T 为 int）；const int* c=&a; func(c);（T 为const int*）。

2. 按引用传递（模板参数为 T&）

• 规则：保留实参的 const 和引用，T 推导为 “实参去掉引用后的类型”。
  • 示例：template<typename T> void func(T& x);
    • int a=10; func(a);（T 为 int，x 为int&）；const int b=20; func(b);（T 为const int，x 为const int&）。
  • 限制：不能传递字面量（非 const 引用无法绑定右值）。

3. 万能引用（模板参数为 T&&）

• 场景：适配左值 / 右值实参，依赖引用折叠规则推导。
• 引用折叠规则：T&+&→T&、T&+&&→T&、T&&+&&→T&&。
• 推导示例：template<typename T> void func(T&& x);
  • 传递左值：int a=10; func(a);（T 为int&，x 为int&）。
  • 传递右值：func(20);（T 为 int，x 为int&&）。
• 完美转发：用std::forward<T>(x)保持实参原始值类别，避免拷贝。
  • 示例：template<typename T> void wrapper(T&& x) { target_func(std::forward<T>(x)); }。

4. 数组与函数名的特殊推导

• 数组推导：
  • 按值传递：数组名转为指针，T 为指针类型（如int arr[5]; func(arr);，T 为int*）。
  • 按引用传递：保留数组类型，T 为元素类型（如template<typename T, size_t N> void func(T(&x)[N]);，T 为 int，N 为 5）。
• 函数名推导：
  • 按值传递：函数名转为指针，T 为函数指针类型（如void add(int,int); func(add);，T 为void(*)(int,int)）。
  • 按引用传递：保留函数类型，T 为函数签名类型（如func(add);，T 为void(int,int)，x 为void(&)(int,int)）。

五、进阶场景：decltype (auto) 与 auto&&

1. decltype (auto)：精确推导的简化写法

• 逻辑：用 auto 的简洁语法，按 decltype 规则推导（保留 const、引用、值类别）。
• 适用场景：函数返回值推导，尤其需保留引用时。
  • 示例：decltype(auto) get_ref(int& x) { return x; }（返回int&）；decltype(auto) get_rval(int x) { return x+1; }（返回 int）。

2. auto&&：多值类别适配工具

• 逻辑：非模板场景的 “万能引用”，依赖引用折叠适配左值 / 右值。
• 适用场景：局部变量接收表达式结果、范围 for 循环（避免拷贝）。
  • 示例：int x=10; auto&& a=x;（a 为int&）；auto&& b=20;（b 为int&&）；for(auto&& val : container)。