C++11标准新增的auto关键字是类型推导工具，编译器会根据变量的初始化表达式自动确定变量的具体类型，不需要开发者手动书写冗长的类型名称，在泛型编程、迭代器使用等场景中能显著提升代码可读性。
auto关键字的基本用法
auto的使用非常简单，只需要在声明变量时把类型位置替换为auto，同时必须给变量提供初始化表达式，因为编译器需要通过初始化值推导类型。
基础使用示例：
#include <iostream>
#include <vector>
#include <string>
int main() {
// 推导为基本类型
auto num = 10; // num推导为int类型
auto price = 3.14; // price推导为double类型
auto name = "test"; // name推导为const char*类型
auto str = std::string("hello"); // str推导为std::string类型
// 推导为引用类型
int a = 5;
auto& ref_a = a; // ref_a推导为int&类型，是a的引用
ref_a = 10; // 修改ref_a会影响a的值
// 推导为指针类型
int* p = &a;
auto ptr = p; // ptr推导为int*类型
auto* ptr2 = &a; // ptr2推导为int*类型
return 0;
}
auto的类型推导规则
auto的推导规则可以分为几个核心场景，理解这些规则才能避免推导结果不符合预期的问题。
1. 非引用非指针的auto声明
当auto声明的变量不是引用也不是指针时，推导会忽略初始化表达式的顶层const和引用属性，保留底层const。
int main() {
const int c_num = 10;
auto num1 = c_num; // num1推导为int，顶层const被忽略
num1 = 20; // 合法，num1不是const类型
const int& ref_c = c_num;
auto num2 = ref_c; // num2推导为int，引用属性被忽略，顶层const也被忽略
num2 = 30; // 合法
const int* const p = &c_num; // 顶层const是指针本身的const，底层const是指向内容的const
auto num3 = p; // num3推导为const int*，保留底层const，忽略顶层const（指针本身的const）
num3 = nullptr; // 合法，num3本身不是const指针
// *num3 = 5; // 非法，num3指向的内容是const的
return 0;
}
2. auto声明为引用或指针
当auto后面跟着&或者*时，推导会保留初始化表达式的底层const，同时引用和指针属性会生效。
int main() {
const int c_num = 10;
auto& ref1 = c_num; // ref1推导为const int&，保留底层const
// ref1 = 20; // 非法，ref1指向的内容是const的
auto* ptr1 = &c_num; // ptr1推导为const int*，保留底层const
// *ptr1 = 20; // 非法，指向的内容是const的
int a = 5;
auto& ref2 = a; // ref2推导为int&
ref2 = 10; // 合法，修改ref2会影响a
return 0;
}
3. auto与初始化列表
如果初始化表达式是花括号初始化列表，auto会推导为std::initializer_list类型，前提是初始化列表的元素类型一致。
#include <initializer_list>
int main() {
auto list1 = {1, 2, 3}; // list1推导为std::initializer_list<int>
auto list2 = {"a", "b"}; // list2推导为std::initializer_list<const char*>
// auto list3 = {1, 2.5}; // 编译错误，初始化列表元素类型不一致，无法推导
return 0;
}
auto的典型使用场景
1. 简化复杂类型声明
当变量类型非常长，比如模板嵌套、迭代器类型时，使用auto可以避免书写冗长的类型名称。
#include <map>
#include <string>
int main() {
std::map<std::string, std::vector<int>> data;
// 不使用auto，迭代器类型非常冗长
std::map<std::string, std::vector<int>>::iterator it1 = data.begin();
// 使用auto，简化书写
auto it2 = data.begin();
return 0;
}
2. 泛型编程场景
在模板函数中，如果返回值类型依赖模板参数，使用auto可以让编译器自动推导返回值类型，简化代码。
template <typename T, typename U>
auto add(T a, U b) {
return a + b; // 返回值类型由a+b的结果自动推导
}
int main() {
auto res1 = add(1, 2); // res1推导为int
auto res2 = add(1.5, 2); // res2推导为double
auto res3 = add(std::string("a"), "b"); // res3推导为std::string
return 0;
}
3. 范围for循环场景
范围for循环中使用auto可以避免手动指定元素类型，提升代码的通用性。
#include <vector>
#include <iostream>
int main() {
std::vector<int> nums = {1, 2, 3, 4, 5};
// 使用auto遍历，不需要关心vector的元素类型
for (auto num : nums) {
std::cout << num << std::endl;
}
// 如果需要修改元素，使用auto&
for (auto& num : nums) {
num *= 2;
}
return 0;
}
使用auto的注意事项
- auto声明的变量必须有初始化表达式，否则编译器无法推导类型，会直接编译报错。
- auto不能用于函数参数声明，函数参数必须明确指定类型。
- auto不能用于声明数组类型，比如
auto arr[] = {1,2,3};是不合法的。 - 当初始化表达式是右值引用时，auto的推导规则会遵循右值引用的相关逻辑，需要结合具体场景判断。