我要评论一、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
gcc/clang 对复合类型的简写规则：
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(); // 比写完整迭代器类型更清晰
到此这篇关于c++11之自动类型推导的实现示例的文章就介绍到这了,更多相关c++11 自动类型推导内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！
发表评论