C++ auto 关键字(C++11) 讲解

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

• 目录

  文章目录

  一、auto 的概念与核心作用

  1. 什么是 auto？

  2.为什么auto方便

  3. 类型推导的基本规则

  二、auto 的使用细则

  1. auto与指针和引用结合起来使用

  2. 在同一行定义多个变量

   三、auto 无法推导的场景 

  1. 函数参数（C++20前）

  2. 数组类型推导

  3. 非静态成员变量（C++11起）

  四、auto 的历史问题 

  1. C++11之前的 auto

  2. C++11的重生

  总结

---

一、auto 的概念与核心作用

1. 什么是 auto？

在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，但遗憾的是一直没有人去使用它，C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一 个新的类型指示符来指示编译器，允许编译器根据变量的初始化表达式自动推断其类型，auto声明的变量必须由编译器在编译时期推导而得。它的核心目标是简化代码，减少冗余的类型声明，同时增强代码的灵活性和可维护性。

2.为什么auto方便

随着程序越来越复杂，程序中用到的类型也越来越复杂，经常体现在：

1. 类型难于拼写    2. 含义不明确导致容易出错

例如：

#include <string>
#include <map>
int main()
{
 std::map<std::string, std::string> m{ { "apple", "苹果" }, { "orange", 
"橙子" }, {"pear","梨"} };
 std::map<std::string, std::string>::iterator it = m.begin();
 while (it != m.end())
 {
 //....
 }
 return 0;
}

std::map<std::string, std::string> >::iterator是一个类型，但是该类型太长了，特别容易写错。假如通过typedef给类型取别名，比如：

#include <string>
#include <map>
typedef std::map<std::string, std::string> Map;
int main()
{
 Map m{ { "apple", "苹果" },{ "orange", "橙子" }, {"pear","梨"} };
 Map::iterator it = m.begin();
 while (it != m.end())
 {
 //....
 }
 return 0;
}

使用typedef给类型取别名确实可以简化代码，但是typedef有会遇到新的难题：

typedef char* pstring;
int main()
{
 const pstring p1;    // 编译成功还是失败？
 const pstring* p2;   // 编译成功还是失败？
 return 0;
}

这样的话我们不止要记得 typedef 定义的char*类型，也需要清楚地知道我们定义的变量p1是否是我们需要的。而不是p1是int类型，但却搞混了。

在编程时，常常需要把表达式的值赋值给变量，这就要求在声明变量的时候清楚地知道表达式的 类型。然而有时候要做到这点并非那么容易，因此C++11给auto赋予了新的含义。

如果使用auto:

#include <string>
#include <map>

int main()
{
 auto m{ { "apple", "苹果" },{ "orange", "橙子" }, {"pear","梨"} };
auto::iterator it = m.begin();
 while (it != m.end())
 {
 //....
 }
 return 0;
}

那么代码就简洁许多，也不用担心是否会编译错误，因为使用 auto 在编译阶段编译器需要根据初始化表达式来推导 auto 的实际类型。

3. 类型推导的基本规则

初始化表达式决定类型：auto变量必须在声明时初始化，类型由右侧的表达式推导而来。

int TestAuto()
{
	return 10;
}
int main()
{
	int a = 10;
	auto b = a;
	auto c = 'a';
	auto d = TestAuto();
	cout << typeid(b).name() << endl;//int
	cout << typeid(c).name() << endl;//char
	cout << typeid(d).name() << endl;//int
	//auto e; 无法通过编译，使用auto定义变量时必须对其进行初始化
	return 0;
}

注意： 使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导 auto 的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编 译期会将auto替换为变量实际的类型。

---

二、auto 的使用细则

1. auto与指针和引用结合起来使用

用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&

int main()
{
    int x = 10;
    auto a = &x;   //auto声明指针类型
    auto* b = &x;  //auto声明指针类型
    auto& c = x;   //auto声明引用类型 c是x的别名

    cout << typeid(x).name() << endl;  //int
    cout << typeid(a).name() << endl;  //int* __ptr64
    cout << typeid(b).name() << endl;  //int* __ptr64
    cout << typeid(c).name() << endl;  //int

    return 0;
}

总结：

auto——什么都可以；auto*——只能是指针；auto&——引用类型，取别名

2. 在同一行定义多个变量

当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。 

void TestAuto()
{
    auto a = 1, b = 2; 
    auto c = 3, d = 4.0;  // 该行代码会编译失败，因为c和d的初始化表达式类型不同
}

---

 三、auto 无法推导的场景 

1. 函数参数（C++20前）

auto不能作为函数的参数 

// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void TestAuto(auto a)
{}

void func(auto x) { }  // C++20前错误！C++20支持简写模板（等价template<typename T>）

2. 数组类型推导

auto不能直接用来声明数组

void TestAuto()
{
    int a[] = {1,2,3};
    //auto b[] = {4，5，6};//错误的
}

3. 非静态成员变量（C++11起）

类中的非静态成员变量无法使用auto，因为类定义时需要确定成员的内存布局：

class MyClass {
    auto value = 10;  // 错误！C++17允许auto静态成员，但非静态仍不可用
    static const auto count = 5;  // C++17允许（需内联初始化）
};

---

四、auto 的历史问题 

1. C++11之前的 auto

在C++98/03中，auto的语义是声明一个自动存储期的局部变量（即变量在代码块结束时自动销毁）。但由于局部变量默认就是自动存储期，该关键字完全冗余：

void old_func() {
    auto int a = 5;  // 等价于 int a = 5;
}

这一设计导致auto长期被程序员遗忘。

2. C++11的重生

C++11重新定义了auto，将其从“废柴”转变为类型推导的利器。这一变革直接解决了以下痛点：

1.消除冗长的模板类型声明（如迭代器）。

2.支持泛型编程中的类型抽象。

3.提升代码的可读性和维护性。

---

总结

1. auto 的优势:代码简洁、泛型友好、维护性高

2. 使用建议:优先使用auto、警惕隐式转换

3. 谨记限制:理解auto的边界，避免在类成员、函数参数（C++20前）等场景误用。