C++11新特性：详解auto关键字

目录

引言

对auto做出改变的意义

C++11之前的auto

C++11之后的auto

类型的推导

auto的优势

auto的使用注意事项

---

引言

🌏博主：R6bandito_

🚀所属专栏：C++新特性

        在C++11中，引入了不少令人惊喜的功能。

其中不乏对类中与类间构造关系的改善（详见《C++11新特性：详解委托构造与继承构造》），

以及对于多态性检查机制的完善（详见《C++11新特性：final与override关键字》）。  

        而对于auto也在新标准之后以全新的面貌焕发新生。从基本无人问津到今天成为开发不可或缺的重要部分，以下我们来详细聊聊auto关键字在新标准之后的用法。

---

对auto做出改变的意义

        为什么要对已早在C++11之前就有定义的auto关键字做出如此改变呢？在这里，我们先来看两个示例：

name = input("请输入你的名字: ")
print(f"你好, {name}!")

#!/bin/bash

echo "请输入你的名字: "
read name
echo "你好, $name!"

以上是分别使用python与bash脚本来实现的一个简单问好程序，我们忽略其它细节，主要关注其变量的使用。发现了什么？没错，

这些程序中的变量name在使用之前没有进行过任何声明，而当程序员需要使用时，便被直接拿来使用。

        对于C/C++开发人员来说，在使用变量之前先定义变量几乎是天经地义的事情，这种如此随性的方式在C/C++用户看来确实是不合规矩。说到这，就不得不提到静态类型语言与动态类型语言了。

• 静态类型语言：

                         静态语言的数据类型是在编译其间确定的或者说运行之前确定的，也就是说，类型检查发生在编译阶段，所以编写代码的时候要明确变量的数据类型。
其代表语言有:C,C++,C#等等

• 动态类型语言：

                              动态类型语言是指在运行期间才去做数据类型检查的语言，也就是说，动态类型语言的数据类型不是在编译阶段决定的，而是把类型绑定延后到了运行阶段。

其代表语言有:Python,JavaScript,PHP等等  

        上述例子中均为动态类型语言，在你第一次赋值给变量时，其在内部就将数据类型记录下来。因此在使用此类动态类型语言编程时，永远也不需要指定变量的数据类型。  

        而在C++11之后，此类类型推导的功能也在静态类型语言c++中得以实现。而实现的方式之一则是通过被重定义的auto关键字。(实现方式还有decltype，这里主要针对auto)

        C++11对auto关键字的重定义，使得代码更加简洁、可读，在一些复杂类型的推导及运用的场景中大大提高了开发效率，也使得代码更加易于维护。

---

C++11之前的auto

        早在c11之前C/C++语言就已经存在了auto关键字。在新标准之前，auto关键字主要用于声明变量的生命周期，与之并列的还有如下关键字：

• auto：自动生命周期管理，意味着变量在进入其作用域时自动分配存储空间，当离开其作用域时，释放掉其存储空间。

• static：声明静态变量，其在整个程序的声明周期中只被初始化一次。在程序结束时方才销毁。

• extern：声明变量来自于外部文件。

        是不是觉得auto的功能在老c++中很熟悉？是的，这正是变量栈空间的自动管理！

auto int m = 10; //在C++98中是正确的，但是在C++11中是不允许的

int m = 10;	//局部变量，生命周期同样是自动管理的

        由于默认情况下，局部变量本身就具备自动生命周期管理的功能，因此通常没有必要去显式的使用auto。所以，在c11标准之前，auto基本很少会被开发人员显式使用出来，因而这个关键字也沦到了无人问津的地步。

---

C++11之后的auto

类型的推导

        C++11之后，标准委员会向auto赋予了全新的意义：auto不再是一个存储类型指示符，而是被定义为了一个全新的类型指示符（类似于int，double等），而由其声明的变量的类型必须由编译器在编译期推导获得。

        从某种意义上来说，auto也可被视作一个类型占位符，在编译期时被自动替换为推导出的变量实际的类型。

        这也侧面说明，由auto声明的变量必须在声明时就对其进行初始化，以便在编译期能够正确推导出其类型，而不能像其它变量一样先声明后定义！

auto a;	//这是绝对不允许的
std::cin >> a;

• 对于常规的基本类型，auto会将变量推导为右值类型：

double get_balance(){}

struct Struct{
	void none(){}
};

void auto_function() {
	auto x = 100;	//x->int
	auto y = 'a';	//y->char
	auto str = "Hello,Cpp"; //str->const char*
	auto PInv = get_balance(); //PInv->double
	auto PInv2 = Struct(); //PInv2->Struct
}

• 而对于带引用的类型，auto将会剥去引用，推导出其原始类型：

int& ref = x;
auto PInv3 = ref;	//PInv3->int

若要保持其引用的特性，可以将auto用&修饰：

int& ref = x;
auto& PInv3 = ref;	//PInv3->int&

直接对变量取引用也是可以的：

auto& PInv4 = y;	//PInv4->char&

• 对于指针类型，auto能够将其正确进行推断：

int *k = &x;
auto PInv5 = k;	//PInv5->int*
auto* PInv_5 = k;	//PInv_5->int*

auto PInv6 = &PInv2;	//PInv6->Struct*
auto* PInv_6 = &PInv2;	//PInv_6->Struct*

对于上述类型而言，使用auto和auto*是等价的。

• 对于数组，auto会将其推到为指向首元素的指针类型：

char str1[15] = "cpluslplus";
auto PInv7 = str1;	//PInv7->char*

int arr[5];
auto PInv8 = arr; //PInv8->int*

• 对于函数，auto也会将其推导为指针：

std::string function(const char* str1, const char* str2) {
	return std::string(str1) + "  "+std::string(str2);
}

auto PInv9 = function;
//PInv9-> std::string (*)(const char*, const char*)

注意：尽管auto能推导函数指针类型。但是以下用法是不允许的！

std::string function(const char* str1, const char* str2) {……}

auto* PInv_2 = &function("Hello", "C++");
/*尽管IDE不会给出错误用法报告，但是无法通过编译。理由是function（）
返回的是一个临时对象，对临时对象取地址是无效的！！*/

auto& PInv_3 = function("Hello", "C++");
/*报错！非常量的左值引用不能与一个临时对象绑定*/

• 对于CV限定符，C++11标准规定auto是可以与cv限定符配合使用的。但是，auto关键字无法从其初始化表达式中带走CV限定符。即：

auto关键字在推导类型时会扒去const和volatile从而取其类型。

当然，若是真想要“带走”也没问题。用cv限制符修饰auto关键字即可保留其特性。

const int m = 45;
auto PInv_4 = m; //PInv_4->int
const auto PInv_4C = m; //PInv_4C->const int

volatile float fval = 2.6f;
auto PInv_5 = fval; //PInv_5->float
volatile auto PInv_5C = fval; //PInv_5C->volatile float

---

auto的优势

        auto关键字的运用场景十分之广。合理运用auto能大大提升程序的可读性，可维护性以及开发的效率。尤其是在c++中引入了命名空间和STL的概念，这使得某些特定的类型可能十分复杂。来看下面这段代码：

std::vector < std::unordered_map <int, std::string>> InitialVec() {
	std::vector < std::unordered_map <int, std::string>> Iamvec;
	/*
		忽略中间的函数实现细节
	*/
	return Iamvec;
}

int main(int argc, const char* argv[]) {
	std::vector < std::unordered_map <int, std::string>> Vec = InitialVec();

	return 0;
}

可以看到vec是一个vector对象，倘若我要获取其迭代器呢？那可能会出现以下代码：

std::vector < std::unordered_map <int, std::string>>::const_iterator iter = Vec.begin();

倘若我要使用基于范围的for循环来遍历这个容器呢？那可能就会出现这种代码：

for(std::unordered_map<int, std::string>& map_val :Vec ){
	/*
		函数实现
	*/
}

        这些代码有错吗？都没错，都符合语法规范。但合适吗？可能有人会觉得合适（答曰俺就爱看长代码有成就感hhh😋），不过很明显，这么写显然是不妥的。这段代码，其涉及的类型比较复杂，如此冗长的代码，我相信无论是谁都不会坐视不管的。

        这还只是一个片段，若是考虑再其它部分，其可读性只会更低，也让写代码的人更容易犯错。而使用auto则可拯救整个局面：

auto InitialVec() {
	std::vector < std::unordered_map <int, std::string>> Iamvec;
	/*
		忽略中间的函数实现细节
	*/
	return Iamvec;
}

int main(int argc, const char* argv[]) {
	auto Vec = InitialVec();

	return 0;
}

auto iter = Vec.begin();

for(auto& map_val :Vec ){
	/*
		函数实现
	*/
}

当然，auto的优势并不只局限于简化代码。还可以帮助用户在声明类型时不会犯错。

如下例代码所示：

class MyWidget {
private:
	const float value = 3.1415926;
public:
	auto operator*(float v){
		return (double)value * v;
	}
};

int main(int argc, const char* argv[]) {
	MyWidget w;
	auto val = w * 4.6f;
	std::cout << val << std::endl;

	return 0;
}

        该代码片段中，我们用一个auto来定义了变量val，而正如我们所意，val被正确推导为了更高精度的double类型。而如果用户不使用auto关键字，则有可能由于其形式，用户并不知道所重载的形式已经提高了精度，从而使用float来定义返回值类型。这样做的代价往往会导致数据可能被截断导致数据精度下降。

        而使用auto就并不用担心这种问题，因为编译器会自动做出最优的解答！

        auto在泛型编程中使用则更加广泛。其中一个比较经典的示例便是其可以搭配decltype进行函数返回类型的追踪。篇幅所限此处我们不具体展开，只介绍其示例：

auto function(){
	/*
		函数实现
	*/
}

template<class _Tx,class _Ty>
auto function_sum(_Tx x, _Ty y)->decltype(function()){	//返回值类型后置
	/*
		函数实现
	*/
	return function();
}

---

auto的使用注意事项

• auto在精度提升方面所存在的问题

/*执行这段代码，会发生什么？*/
void func() {
	int te = 2147483647;
	int b = 1;
	auto val = te + b;

	std::cout<< val << std::endl;
}
// Output:
// -2147483648

想必看了上述代码，大家已经有所察觉了。auto关键字尽管可以帮助用户解决一些用户在声明类型时可能存在的精度问题。但是实际上，尽管数据已经溢出，但是auto推导出的仍然为int类型，其数据类型并不会自动拓展到更高精度。这也是与其它动态类型语言有所区别的地方。

• 不要什么场合都用auto！

        auto是用于简化问题，简化代码提高效率的，而不应该被滥用！过分使用auto有时候反而会使得代码不明了，变得更不易读，违背了使用的初衷。尤其是对于基本类型以及在代码一些关键功能实现部分，有时候能够一眼看出类型的代码远远优于在一堆auto中追根溯源的代码（于人于己都好）。

• auto不能用作形参！

请牢记，以下用法是绝对错误的：

auto example(auto x = 1, auto y = 2) {
	/*没有这种用法！*/
	return x * y;
}

int main(int argc, const char* argv[]) {
	example(10, 20);
	return 0;
}

若想要进行泛型编程，请移步template。

• auto不能推导类中非静态成员变量的类型！

class Exam {
	/*同样没有这种用法*/
public:
	auto x = 5;
	auto str = "Hello,C++";
};

• auto不能用于声明数组

        请切记，这种用法是可以的：

int arr[5] = { 1, 2, 3, 4, 5 };
auto k = arr; //k->int*

        但是，这种用法不行:

int array[5];
auto arr[5] = array; //报错

• auto不能用来实例化模板参数

std::vector<auto> vec = { 'a','b' }; //报错

虽然此种方式与声明数组一样，用户都能一眼看出其类型，但是编译器并不会予以通过。

因此，在日后使用auto时，若出现不太符合预期的行为，应回头看看是不是违反了其中某一条限制。

---

感谢支持！！🌹🌹