C++11 之 自动类型推导

一、auto 的基本概念

auto 是一个类型占位符，而非一个真正的类型。当你用auto声明变量时，编译器会根据变量的初始化表达式自动推导出变量的实际类型，然后将auto替换为这个类型。

核心要求：用 auto 声明的变量必须初始化，否则编译器无法推导类型。

#include <iostream>
#include <string>
#include <vector>
using namespace std;

int main() {
    // 1. 基本类型推导
    auto a = 10;          // 推导为 int
    auto b = 3.14;        // 推导为 double
    auto c = 'A';         // 推导为 char
    auto d = true;        // 推导为 bool
    auto e = "hello";     // 推导为 const char*（字符串字面量是const char[]）
    auto f = string("hi");// 推导为 std::string

    // 验证推导结果（通过typeid查看类型）
    cout << typeid(a).name() << endl; // 输出：int（不同编译器输出可能略有差异，比如MSVC输出int，GCC输出i）
    cout << typeid(e).name() << endl; // 输出：const char*

    // 2. 复杂类型推导（解决冗长类型名问题）
    vector<vector<int>> matrix = {{1,2}, {3,4}};
    // 传统写法：vector<vector<int>>::iterator it = matrix.begin();
    auto it = matrix.begin(); // 推导为 vector<vector<int>>::iterator
    cout << (*it)[0] << endl; // 输出：1

    return 0;
}

执行结果:

i
PKc
1

• P = Pointer（指针）
• K = const（Konst，德语 “常量” 的缩写，C++ 标准里用 K 表示 const）
• c = char所以 PKc 组合起来就是 const char*（按顺序：P (指针) + K (const) + c (char)）

二、auto 的推导规则

auto的推导规则和模板参数推导基本一致，核心分三种情况：

规则 1：初始化表达式是普通类型（非引用、非指针）

auto会推导出和初始化表达式完全一致的类型（忽略顶层 const/volatile）。

#include <iostream>
using namespace std;

int main() {
    const int x = 10;
    auto y = x;         // y的类型是int（顶层const被忽略）
    y = 20;             // 可以修改，证明y不是const
    
    const auto z = x;   // z的类型是const int（手动加const，保留常量属性）
    // z = 30;          // 编译错误：z是const int，不能修改

    volatile int m = 20;
    auto n = m;         // n的类型是int（顶层volatile被忽略）

    return 0;
}

规则 2：初始化表达式是引用 / 指针

• 如果表达式是引用，auto会推导出被引用的类型（忽略引用）；

• 如果表达式是指针，auto会保留指针属性；

• 如果是底层 const的指针 / 引用，auto会保留底层 const。

#include <iostream>
using namespace std;

int main() {
    int val = 100;
    int& ref_val = val;
    
    auto a = ref_val;   // a的类型是int（忽略引用）
    a = 200;
    cout << val << endl; // 输出：100（a是拷贝，不影响val）

    auto& b = ref_val;  // b的类型是int&（手动加&，保留引用）
    b = 200;
    cout << val << endl; // 输出：200（b是引用，修改影响val）

    const int c = 50;
    const int& ref_c = c;
    auto d = ref_c;     // d的类型是int（忽略引用，顶层const也忽略）
    auto& e = ref_c;    // e的类型是const int&（保留底层const和引用）
    // e = 60;          // 编译错误：e指向const int

    int* p = &val;
    auto q = p;         // q的类型是int*（保留指针）
    const int* pc = &c;
    auto r = pc;        // r的类型是const int*（保留底层const的指针）

    return 0;
}

规则 3：初始化表达式是数组 / 函数

• 数组名作为表达式时，auto会推导为指针类型；

• 函数名作为表达式时，auto会推导为函数指针类型。

#include <iostream>
using namespace std;

void func() {
    cout << "func called" << endl;
}

int main() {
    int arr[5] = {1,2,3,4,5};
    auto a = arr;       // a的类型是int*（数组退化为指针）
    cout << *(a+1) << endl; // 输出：2

    auto& b = arr;      // b的类型是int (&)[5]（数组的引用，保留数组类型）
    cout << b[2] << endl;   // 输出：3
    cout << sizeof(b) << endl; // 输出：20（5个int，每个4字节）

    auto f = func;      // f的类型是void (*)()（函数指针）
    f();                // 调用func，输出：func called

    return 0;
}

三、auto 的核心使用场景

auto不是 “万能的”，但在以下场景能极大提升代码可读性和开发效率：

场景 1：简化冗长的类型名

这是auto最核心的用途，尤其是 STL 容器的迭代器、函数返回值类型复杂的场景。

#include <iostream>
#include <map>
#include <string>
using namespace std;

int main() {
    // 复杂容器的迭代器
    map<string, map<int, string>> complex_map;
    complex_map["user1"][1001] = "Tom";
    
    // 传统写法（冗长且易出错）：
    // map<string, map<int, string>>::iterator it = complex_map.begin();
    auto it = complex_map.begin(); // 简洁明了
    cout << it->first << ": " << it->second[1001] << endl; // 输出：user1: Tom

    return 0;
}

场景 2：遍历容器（配合范围 for 循环）

这是 C++11 后最常用的组合写法，彻底摆脱手动管理迭代器 / 索引。

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> nums = {10,20,30,40};
    
    // 只读遍历（拷贝）
    for (auto val : nums) {
        cout << val << " ";
    }
    cout << endl;

    // 修改遍历（引用）
    for (auto& val : nums) {
        val *= 2;
    }

    // 只读遍历（const引用，避免拷贝，效率更高）
    for (const auto& val : nums) {
        cout << val << " "; // 输出：20 40 60 80
    }

    return 0;
}

场景 3：配合 Lambda 表达式

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

int main() {
    vector<int> nums = {3,1,4,1,5,9};
    
    // Lambda表达式的变量必须用auto声明
    auto compare = [](int a, int b) { return a > b; };
    sort(nums.begin(), nums.end(), compare);

    for (auto val : nums) {
        cout << val << " "; // 输出：9 5 4 3 1 1
    }

    return 0;
}

场景 4：处理模板类型

在模板编程中，auto可以简化模板参数推导后的类型声明。

#include <iostream>
using namespace std;

template <typename T1, typename T2>
auto add(T1 a, T2 b) -> decltype(a + b) { // C++11尾返回类型（配合auto）
    return a + b;
}

int main() {
    auto res1 = add(10, 20.5); // res1推导为double（10+20.5=30.5）
    auto res2 = add(5, 3);     // res2推导为int（5+3=8）
    cout << res1 << " " << res2 << endl; // 输出：30.5 8

    return 0;
}

四、auto 的注意事项（避坑指南）

1. 必须初始化

auto是 “推导” 类型，没有初始化值就无法推导，编译会报错。

// 错误示例
auto x; // 编译错误：auto变量必须初始化
x = 10;

2. 不能用于函数参数

auto不能直接作为函数参数类型（C++14 支持auto作为函数返回值，但参数仍不支持）。

// 错误示例
void func(auto x) { // 编译错误：参数不能用auto
    cout << x << endl;
}

// 正确替代方案：用模板
template <typename T>
void func(T x) {

3. 不能用于数组声明

auto不能直接声明数组，但可以推导数组的引用或指针。

// 错误示例
auto arr[5] = {1,2,3,4,5}; // 编译错误：auto不能声明数组

// 正确写法
int raw_arr[5] = {1,2,3,4,5};
auto* arr_ptr = raw_arr;    // 推导为int*
auto& arr_ref = raw_arr;    // 推导为int (&)[5]

4.推导可能 “丢失” const / 引用属性

如前面的规则所述，auto默认会忽略顶层 const 和引用，如需保留，需手动加const/&。

int val = 10;
const int& ref = val;

auto a = ref;       // a是int，丢失const和引用
const auto& b = ref;// b是const int&，保留属性

5. 避免过度使用

auto能简化代码，但过度使用会降低可读性（比如简单类型也用 auto）。

// 不推荐（可读性差）
auto x = 10; // 直接写int x = 10更清晰

// 推荐（类型冗长）
vector<map<int, string>> vec;
auto it = vec.begin(); // 比写完整迭代器类型更清晰