【C++深入浅出】初识C++下篇（auto关键字、范围for、nullptr指针）

r囧r小猫 2024-04-25 20:06 6阅读 0赞

![62b0582cc5f742aaae1d5e40c73cf32a.jpeg][]

--------------------

**目录**

一. 前言

二. auto关键字

2.1 auto的引入

2.2 auto简介

2.3 auto的使用细则

2.4 auto不能推导的场景

三. 基于范围的for循环(C++11)

3.1 范围for的语法

3.2 范围for的原理

3.3 范围for的使用条件

四. 指针空值nullptr(C++11)

--------------------

### 一. 前言 ###

上期我们介绍了c++新增的两个重要语法：引用和内联函数，今天我们带来的内容是**auto关键字**、**范围for**以及**nullptr指针**，本期也是初识C++的最后一期。上期回顾：

[【C++深入浅出】初识C++中篇（引用、内联函数）![icon-default.png?t=N7T8][icon-default.png_t_N7T8]http://t.csdn.cn/LCvY0][C_C_icon-default.png_t_N7T8_icon-default.png_t_N7T8_http_t.csdn.cn_LCvY0] **话不多说，直接上菜！！！**

### 二. auto关键字 ###

#### 2.1 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 其实是一个类型，是不是非常吓人![6b6378a8805544d18d4807ded4535078.gif][]。像这种长类型特别容易写错，有的人可能已经想到了解决方案：可以通过typedef给类型取别名。是的，这无疑也是种好方法，但使用typedef前我们必须先知道类型，有时候这并不容易做到。那怎么办呢？不急，C++11中的auto关键字就是为了解决这个问题。

#### 2.2 auto简介 ####

在早期C/C++中使用auto修饰的变量，是具有自动存储器的局部变量，但由于用处不大，一直没有人去使用它。

而在C++11中，C++标准委员会赋予了auto全新的含义，即auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，使用auto声明的变量类型编译器会在编译时期自动推导而得。

为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法。

#include<string>
    int TestAuto()
    {
    	return 10;
    }
    int main()
    {
    	int a = 10;
    	string s;
    	auto b = a;
    	auto c = 'a';
    	auto d = TestAuto();
    	auto e = s.begin();
    	cout << typeid(b).name() << endl; //typeid类似于sizeof一样，是一个操作符，其可以用来获取变量的类型。
    	cout << typeid(c).name() << endl;
    	cout << typeid(d).name() << endl;
    	cout << typeid(e).name() << endl;
    	//auto e; 无法通过编译，使用auto定义变量时必须对其进行初始化
    	return 0;
    }

输出结果如下![a23cde1d6b5f404abc2b1f7353f05853.png][]

![e81a49f5502a4f8fbbee0109fca4e8f8.png][]

> 可以看出，编译器自动帮我们将类型推导出来了，是不是非常方便![3497bba8117949eb857896f3afff6fb7.gif][]

#### 2.3 auto的使用细则 ####

学会了auto的基本使用，接下来就是避坑时间惹![55aa9e8956f0431b8b8ce1b98500f9ff.gif][]

**1. auto定义变量时必须对其进行初始化**

auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”。在编译阶段编译器需要根据初始化表达式来推导auto的实际类型，然后将auto替换为变量实际的类型。

int main()
    {
    	int val = 10;
    	auto a; //错误写法，编译时会报错
    	auto b = val; //正确写法，定义时进行初始化，编译器才能进行推导然后将auto替换
    	return 0;
    }

**2.auto和指针和引用**

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

int main()
    {
    	int x = 10;
    	auto a = &x;
    	auto* b = &x;
    	auto& c = x;
    	cout << typeid(a).name() << endl;
    	cout << typeid(b).name() << endl;
    	cout << typeid(c).name() << endl;
    	*a = 20;
    	*b = 30;
    	c = 40;
    	return 0;
    }

![58402f3a4b434ebaae580f6e469cde9d.png][]

**3. 在同一行定义多个变量**

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

int main()
    {
    	auto a = 1, b = 2; // 正确写法
    	auto c = 3, d = 4.0; // 编译失败，因为c和d的初始化表达式类型不同
    
    	return 0;
    }

![5e8c0d4e38a445009b70f955788066f8.png][]

#### 2.4 auto不能推导的场景 ####

**1、auto不能作为函数的参数**

// 此处代码编译失败，auto不能作为形参类型，
    // 原因：函数调用传参发生在运行阶段，故在编译阶段编译器无法对a的实际类型进行推导
    void TestAuto(auto a)
    {}

![4c360fc235c44ed39e024b9b7b6f4635.png][]

**2.、auto不能直接用来声明数组**

int main()
    {
    	int a[] = { 1,2,3 };
    	auto b[] = { 4,5,6 };
    	return 0;
    }

![27612ae197f34d58bffe6767f04454da.png][]

--------------------

### 三. 基于范围的for循环(C++11) ###

#### 3.1 范围for的语法 ####

在C++98中如果要遍历一个数组，可以按照以下方式进行：

int main()
    {
    	int array[] = { 1, 2, 3, 4, 5 };
    	for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
    	{
    		array[i] *= 2; //利用下标访问
    	}
    	cout << endl;
    	for (int* p = array; p < array + sizeof(array) / sizeof(array[0]); ++p)
    	{
    		cout << *p << ' '; //利用指针访问
    	}
    	cout << endl;
    
    }

但是对于array这个有范围的集合而言，由程序员来说明循环的范围显然显得有点多余，有时候还会容易犯错误产生越界。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号分为两部分：第一部分是范围内迭代取得的变量，第二部分则表示进行迭代的集合对象。上述代码使用范围for改写如下![946bbdc5266b438696241783b725bdaa.png][]

int main()
    {
    	int array[] = { 1, 2, 3, 4, 5 };
    	for (auto& e : array) //依次取数组的数据给引用变量e，自动判断结束，自动迭代 + 1
    	{
    		e *= 2;
    	}
    	for (auto e : array) //依次取数组的数据赋值给变量e，自动判断结束，自动迭代 + 1
    	{
    		cout << e << " ";
    	}
    	return 0;
    }

> 可以看到，我们使用到了之前学的auto关键字，利用auto的自动类型推导，我们无需显式地写出e的类型，使得范围for的使用更加简洁方便，这也是auto的常见优势用法之一。
> 
> --------------------
> 
> 在第一个范围for中，由于e是引用变量，因此e表示的是数组每个元素的别名，对e进行修改就是对数组元素进行修改。
> 
> 而在第二个范围for中，e是普通变量，表示的是数组每个元素的拷贝，对e进行修改对数组元素没有影响。
> 
> --------------------
> 
> **注意：**与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环。

#### ![4f76be590bc5487b8f46c6ed51be54bb.png][] ####

--------------------

#### 3.2 范围for的原理 ####

可能会有的小伙伴会好奇：范围for这个东西这么智能，既能自动迭代，还能自动判断结束，那么它的原理究竟是什么呢![36afa72d680b4955880bf93e4d3e145a.gif][]

实际上，并没有想象中的那么复杂。范围for的底层原理实际上就是迭代器遍历，编译器在编译时会自动将范围for的代码替换为迭代器遍历相关代码。迭代器的知识我们后续会介绍，这里大家将其理解为指针即可。

下面是一段vector容器的遍历代码：

int main()
    {
    	vector<int> v;
    	for (int i = 1; i <= 5; i++) //插入1-5的数据
    	{
    		v.push_back(i);
    	}
    
    	for (auto e : v) //范围for遍历
    	{
    		cout << e << ' ';
    	}
    	cout << endl;
    	return 0;
    }

编译器编译时范围for会替换成类似于如下的代码：

int main()
    {
    	vector<int> v;
    	for (int i = 1; i <= 5; i++) //插入1-5的数据
    	{
    		v.push_back(i);
    	}
    
    	vector<int>::iterator it = v.begin();
    	//auto it = v.begin(); //迭代器的类型较长，也可以使用auto自动推导
    
    	while (it != v.end()) //迭代器遍历，这里将it当做指针理解即可
    	{
    		cout << *it << ' ';
    		it++;
    	}
    	cout << endl;
    	return 0;
    }

> **结论：**范围for其实就是编译器进行了替换，本质上还是迭代器的遍历。

#### 3.3 范围for的使用条件 ####

**1、for循环迭代的范围必须是确定的**

对于数组而言，for循环迭代的范围就是从数组中第一个元素到最后一个元素；对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围。

void putArray(int array[])
    {
    	//数组传参发生降维，array是个指针，指向数组首元素
    	for (auto e : array) //由于array只是个int*指针，我们无法确定迭代的范围，故这里的范围for会报错
    	{
    		cout << e << ' ';
    	}
    }
    int main()
    {
    
    	vector<int> v;
    	for (int i = 1; i <= 5; i++) //插入1-5的数据
    	{
    		v.push_back(i);
    	}
    
    	for (auto e : v) //范围for遍历vector容器类。范围：v.begin()~v.end()
    	{
    		cout << e << ' ';
    	}
    	cout << endl;
    
    	int array[5] = { 1,2,3,4,5 };
    	for (auto e : v) //范围for遍历array数组。范围：从第一个元素的下标0到最后一个元素的下标4
    	{
    		cout << e << ' ';
    	}
    
    	putArray(array);
    	return 0;
    }

**2、迭代的对象要实现++和==的操作**

上面我们看到范围for替换为迭代器遍历的代码中，使用迭代器it进行遍历时需要用到++和==的操作，顾迭代器需要支持++和==的操作。（目前不清楚的了解一下即可，等到我们讲解迭代器时再深入讨论）

--------------------

### 四. 指针空值nullptr(C++11) ###

在C语言中，我们对指针进行初始化时，经常会用NULL空指针进行初始化，如下：

int main()
    {
    	int* p1 = NULL;
    	return 0;
    }

实际上，NULL是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：

![fea5b4a030104422998960e61af02c63.png][]

可以看到，NULL在C++中被定义为字面常量0，在C语言中被定义为无类型指针(void\*)常量。而字面常量0在编译器看来默认是整形常量，这就会导致出现一些不可预料的错误，例如：

void f(int)
    {
    	cout << "f(int)" << endl;
    }
    void f(int*)
    {
    	cout << "f(int*)" << endl;
    }
    int main()
    {
    	f(0);
    	f(NULL);
    	f((int*)NULL);
    	return 0;
    }

上述代码在C++中的结果如下所示![6d5921f92f6d4c1b89391c45d996d13d.png][]

![8c9d0f534fb04a4e86bdfd4c4262eb86.png][]

> 本意我们是想通过f(NULL)调用指针版本的f(int\*)函数，但是由于NULL在C++中被定义成字面常量0，因此调用了更符合的f(int)函数，与程序的初衷相悖。如果我们执意要调用f(int\*)函数，只能将NULL强制类型转换为int\*，再进行调用即可，但这样会显得非常奇怪![b02caacb91d549e3af72c3c9d9842303.gif][]

--------------------

出于以上原因，C++11新增了一个关键字nullptr用来表示指针空值，如下：

void f(int)
    {
    	cout << "f(int)" << endl;
    }
    void f(int*)
    {
    	cout << "f(int*)" << endl;
    }
    int main()
    {
    	f(0);
    	f(nullptr); //nullptr表示空指针
    	return 0;
    }

此时代码的结果就符合我们初衷了：![89ec5b9496874d47ba8c9cb9335de733.png][]

> **关于nullptr的几点说明与建议** 
> 
> 1.  在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。
> 2.  在C++11中，sizeof(nullptr) 与 sizeof((void\*)0)所占的字节数相同。
> 3.  为了提高代码的健壮性，在C++中表示指针空值时最好使用nullptr。

--------------------

***以上，就是本期的全部内容啦*****🌸**

***制作不易，能否点个赞再走呢*****🙏**

[62b0582cc5f742aaae1d5e40c73cf32a.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/7ad0fddfab5c4d478e32f599203ed440.jpeg
[icon-default.png_t_N7T8]: https://csdnimg.cn/release/blog_editor_html/release2.3.6/ckeditor/plugins/CsdnLink/icons/icon-default.png?t=N7T8
[C_C_icon-default.png_t_N7T8_icon-default.png_t_N7T8_http_t.csdn.cn_LCvY0]: http://t.csdn.cn/LCvY0
[6b6378a8805544d18d4807ded4535078.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/cae56321268e41609576073c74000cfe.gif
[a23cde1d6b5f404abc2b1f7353f05853.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/260ce3aee5bb4be4a7966810bb8a9baa.png
[e81a49f5502a4f8fbbee0109fca4e8f8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/0f8d80d82b2441e4af20138781dacda6.png
[3497bba8117949eb857896f3afff6fb7.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/5a1402195b5b4b0a93002119d700e954.gif
[55aa9e8956f0431b8b8ce1b98500f9ff.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/11aa6186d3844fd8a969ef66463b20ce.gif
[58402f3a4b434ebaae580f6e469cde9d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/64a0c60d24914e098e457e2b2bc00fa3.png
[5e8c0d4e38a445009b70f955788066f8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/c3bfe81576284f4b8507e623c94a4132.png
[4c360fc235c44ed39e024b9b7b6f4635.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/44542672a3c244dc867c47d7b2b3f308.png
[27612ae197f34d58bffe6767f04454da.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/1134eb2eed784498b2ffeb1841394210.png
[946bbdc5266b438696241783b725bdaa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/161cb4324eab469ea5d5cbb833575df3.png
[4f76be590bc5487b8f46c6ed51be54bb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/ac8b50c388e24a98b69a16d6216a8069.png
[36afa72d680b4955880bf93e4d3e145a.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/f73cdb0b8c1b4c98818f50f152e1cbda.gif
[fea5b4a030104422998960e61af02c63.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/b9f9f97db77049d7b4e6f07ef5c640c5.png
[6d5921f92f6d4c1b89391c45d996d13d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/fca2d2b43b6d4a3e8ee08865770dbe38.png
[8c9d0f534fb04a4e86bdfd4c4262eb86.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/5622f137347a4520b03c0f55b4431848.png
[b02caacb91d549e3af72c3c9d9842303.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/c2620ab836b4487088ece0250741ce98.gif
[89ec5b9496874d47ba8c9cb9335de733.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/25/f7725123eb8443949567bdb0d510d09e.png