auto关键字（C++11）_c++11 auto关键字

auto关键字（C++11）

---

---

前言

在C++11中，auto关键字能够自动推导出变量的实际类型，可以帮助我们写出更加简洁、现代的代码。

---

一、auto使用规则

1. C++中auto关键字并不代表一种实际的数据类型，只是一个类型声明的"占位符"，auto的使用场景也有限制，并不是万能的，使用auto声明的变量必须进行初始化，只有这样才能让编译器根据初始化的值推导出变量的实际数据类型，在编译时将auto占位符替换成真正的数据类型。
2. auto还可以跟指针和引用结合起来，搭配上const、volatile限定符，在不同的场景有对应的推导规则，规则内容如下：
   当变量不是指针或者引用类型时，推导的结果中不会保留const、volatile关键字；当变量是指针或者引用类型时，推导的结果中会保留const、volatile关键字

语法如下：

// var--变量名;value--变量值
auto var=value;
1
2

示例程序：

#include <iostream>
using namespace std;

int main()
{
	// 无const修饰
	auto var = 3.14;
	auto var1 = 100;
	auto var2 = 'z';
	auto var3;	//错误❌，使用auto关键字必须初始化
	
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

鼠标放在变量上会自动显示编译器推导出的数据类型。
指针和引用的auto推导示例代码：

#include <iostream>
using namespace std;

int main()
{
	// 带指针和引用的auto使用
	int var = 100;

	//&var:int*	; auto:int
	auto* var1 = &var;
	//var:int	; auto:int
	auto& var2 = var;
	//&var:int*	; auto:int*
	auto var3 = &var;
	//var:int	; auto:int
	auto var4 = var;

	// auto在const情况下的使用
	//var:int	; auto:int	; var5:const int
	const auto var5 = var;
	//var5:const int	; auto:int	; var6:int
	auto var6 = var5;
	//var:int	; auto:int	; var7:const int
	const auto& var7 = var;
	//var7:const int	; auto:const int	; var8:const int
	auto& var8 = var7;
	//var7:const int	; auto:const int	; var9:const int*
	auto* var9 = &var7;
	
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

备注：
指针常量和常量指针的区别：
指针常量（int* const）：指针的指向不可以改变，指针指向的值可以改变。
常量指针（const int*）：指针的指向可以改变，指针指向的值不可以改变。
可以通过这一句话记忆，指针常量，即指针是常量；常量指针，即常量的指针。

二、auto不适用的场景

1. 不能用于函数的形参数据类型的推导。因为函数的形参的初始化只有在函数被调用时才会被传递实参，因此二者矛盾。

void fun(auto a)	//错误❌
{
	cout<<a<<endl;
}
1
2
3
4

2. 不能用于类的非静态常量变量的初始化。因为类的非静态成员（不属于类，属于类对象的）的初始化只有在类创建对象时才会成立，另外静态非常量成员的初始化要在类外实现，因此auto都不可以用来推导这两种类型的推导。

class Test {
	auto var = 0;					//错误
	static auto var1 = 100;			//错误,类的静态非常量成员的初始化不允许在类的内部
	static const auto var2 = 200;	//类的静态常量成员初始化可以在类的内部完成
};
1
2
3
4
5

3. 不能用auto关键字定义数组

int main()
{
	int array[] = { 1,2,3,4 };	//定义数组
	auto var = array;			//auto:int *
	auto var1[] = array;		//错误❌，auto不能用来定义数组
	auto var2[] = { 1,2,3,4 };	//错误❌，auto不能用来定义数组

	return 0;
}
1
2
3
4
5
6
7
8
9

4. 无法使用auto推导出模板参数类型

template<class T>
class Test {
	T t;
};


int main()
{
	Test<double> t;
	Test<auto> t1 = t;	//错误❌,auto无法推导出类模板类型

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

三、auto推荐适用的场景

1. 用于STL容器的遍历

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


int main()
{
	vector<int> vec;
	vec.push_back(1);
	vec.push_back(2);
	vec.push_back(3);
	vec.push_back(4);

	//STL容器遍历
	//vector<int>::iterator it=vec.begin();
	auto it = vec.begin();		//auto自动推导迭代器类型,代码简洁
	for (; it < vec.end(); it++)
	{
		cout << *it << endl;
	}

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

2. 用于接收模板函数的返回值

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

class Test
{
public:
	static int get()
	{
		return 10;
	}
};

class Test1
{
public:
	static string get()
	{
		return "hello world";
	}
};


template <class T>
void func()
{
	auto ret=T::get();
	cout << ret << endl;
}



int main()
{
	func<Test>();
	func<Test1>();

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

---

总结

本文主要介绍了auto的使用、带指针和引用的auto的使用以及注意事项、推荐使用的场景，欢迎有问题交流。