【C++】基础语法2（引用，内联，auto，范围for，nullptr）

分手后的思念是犯贱 2021-09-08 22:30 288阅读 0赞

### 文章目录 ###

*  一、引用
 *   *  1.概念
     *  2. 引用特性
     *  3.常引用
     *  3.引用的使用场景
     *   *  （1）做参数
         *  （2）做返回值
     *  4.引用和指针的区别
 *  二、内联函数
 *   *  1.概念
     *  2.特性
     *  3.与\#define的区别
 *  三、auto关键字（C++11）
 *   *  1.概念
     *  2.使用注意事项
     *   *  （1）auto与指针和引用结合起来使用
         *  （2）在同一行定义多个变量
         *  （3）auto不能使用的场景
 *  四、范围for（C++11）
 *   *  1.语法
     *  2. 范围for的使用条件
 *  五、nullptr（C++11）
 *  感谢阅读，如有错误请批评指正

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

# 一、引用 #

## 1.概念 ##

**引用**不是新定义一个变量，而是给已存在变量取了一个**别名**，编译器不会为引用变量开辟内存空间，它和它引用的变量**共用同一块内存空间**。

用法：**类型& 引用变量名(对象名) = 引用实体**

如下面的代码

代码如下（示例）：

int main()
    { 
    	int a = 0;
    	int& b = a;//b是a的引用
    	int& c = a;//c是a的引用
    	cout << &a << endl;
    	cout << &b << endl;
    	cout << &c << endl;
    	cout << endl;
    
    	c = 2;//若改为b = 2;或a = 2;结果相同
    	cout << a << endl;
    	cout << b << endl;
    	cout << c << endl;
    	cout << endl;
    	return 0;
    }

运行结果如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA_size_16_color_FFFFFF_t_70_pic_center]  
运行后可以看到，a、b、c三个变量的地址一样，说明他们所在的内存空间相同。由此可知，对a、b、c任一变量的修改都会影响其它两个变量的值。

**注意：引用类型必须和引用实体是同种类型的**

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

## 2. 引用特性 ##

**（1）引用在定义时必须初始化。  
（2）一个变量可以有多个引用。  
（3）一旦引用一个实体就不能再引用其他实体。**

代码如下（示例）：

int main()
    { 
    	int a = 0;
    	int& ra;//编译出错，因为在定义时没有初始化
    	
    	//b、c都是a的引用
    	int& b = a;
    	int& c = a;
    	
    	int d = 2;
    	c = d;
    	//这样写并不是将c变成d的引用，而是把d的值赋给c
    	//由于c是a的引用，也就相当于将d的值赋给a
    	
    	return 0;
    }

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

## 3.常引用 ##

由于被const修饰的变量只能使用而不能修改（即只读），这里在引用时会出现一些情况

代码如下（示例）：

int main()
    { 
    	const int a = 10;//只读变量
    	int& ra = a; //该语句编译时会出错，因为a是只读的变量，但ra作为a的引用确可读可写（权限变大）
    	const int& ra = a;//正确
    	
    	int b = 10;//可读可写
    	const int& b = 10;//只读，正确（权限变小）
    	return 0;
    }

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

## 3.引用的使用场景 ##

### （1）做参数 ###

代码如下（示例）：

void Swap(int& x, int& y)
    { 
    	int temp = x;
    	x = y;
    	y = temp;
    }
    
    int main()
    { 
    	int a = 10;
    	int b = 20;
    	cout << a << " " << b << endl;
    	Swap(a, b);
    	cout << a << " " << b << endl;
    	return 0;
    }

上面的代码中调用函数Swap时x是a的引用，这两个变量代表同一块内存空间，对x的修改就是对a的修改，y和b同理。所以不需要使用指针就可以完成变量内容的交换。

**当参数或返回值是内存较大的变量或类时，传引用传参和传引用做返回值可以提高程序的效率。只要符合条件，尽量引用传参、做返回值。**

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

### （2）做返回值 ###

**不是在所有情况下引用都可以做返回值**

下面是很简单的一个实现加法的程序。

代码如下（示例）：

int Add(int a, int b) //传值返回
    { 
    	int c = a + b;
    
    	return c;
    }
    
    int main()
    { 
    	int ret = Add(1, 2);
    	cout << "Add(1, 2) = " << ret << endl;
    	return 0;
    }

上面的Add函数传值返回，先把c的值给一个临时变量，接着ret接收这个临时变量的值，Add中return的其实是c的拷贝（一个int类型的临时变量）。

为什么要这样处理呢？

因为c可能是Add函数栈帧内的一个临时变量，返回时Add函数的栈帧已经销毁，c的值也变成了随机值，返回的值就不是原来c的值了。

代码如下（示例）：

//传引用返回
    int& Add(int a, int b) 
    { 
    	int c = a + b;
    	return c;
    }
    
    int main()
    { 
    	int& ret = Add(1, 2);
    	cout << "Add(1, 2) = " << ret << endl;
    	return 0;
    }

上面的Add函数是传引用返回，ret就是函数中c的引用，但是这种写法是有问题的，因为Add调用结束以后c被销毁，再访问ret（相当于访问c）是非法的，得到的结果是不确定的。

注意：**如果函数返回时，出了函数作用域，如果返回对象还未还给系统，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。**

代码如下（示例）：

int& Add(int a, int b) 
    { 
    	//c是静态变量，储存在静态区且只在第一次运行的时候初始化。函数栈帧的创建与销毁不会影响c
    	static int c = a + b;
    	return c;
    }
    int main()
    { 
    	int& ret = Add(1, 2);//ret = 3
    	//调用Add(1, 2)后c的值被初始化为3，不会再改变
    	Add(3, 4);
    	cout << "Add(3, 4) = " << ret << endl;//输出Add(3, 4) = 3
    	return 0;
    }

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

## 4.引用和指针的区别 ##

1.  引用在定义时必须初始化；指针没有要求
2.  引用在初始化时引用一个实体后，就不能再引用其他实体；指针可以在任何时候指向任何一个同类型实体
3.  没有NULL引用，但有NULL指针
4.  在sizeof中含义不同：引用结果为引用类型的大小；指针始终是地址空间所占字节个数(32位平台下占4个字节，64位平台下占8个字节)
5.  引用自加即引用的实体数值增加1；指针自加即指针向后偏移一个类型的大小
6.  有多级指针；没有多级引用
7.  访问实体方式不同，引用编译器自己处理；指针需要显式解引用
8.  引用比指针使用起来相对更安全

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

# 二、内联函数 #

## 1.概念 ##

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，**没有函数压栈的开销，内联函数提升程序运行的效率**。

代码如下（示例）：

int Add(int a, int b) 
    { 
    	int c = a + b;
    
    	return c;
    }
    int main()
    { 
    	int ret = Add(1, 2);
    	return 0;
    }

这段代码在反汇编下查看时，很明显看到程序调用（call）Add函数，如果Add函数多次调用，频繁地call会使程序效率下降。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA_size_16_color_FFFFFF_t_70_pic_center 1]

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

而在Add函数前加上inline使其成为内联函数后再次运行。

代码如下（示例）：

inline int Add(int a, int b) 
    { 
    	int c = a + b;
    
    	return c;
    }
    int main()
    { 
    	int ret = Add(1, 2);
    	return 0;
    }

查看反汇编，很明显反汇编代码减少了，同时没有出现call Add，这就能够提升程序的效率。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA_size_16_color_FFFFFF_t_70_pic_center 2]

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

## 2.特性 ##

（1）**inline是一种以空间换时间的做法，省去调用函数额开销**。所以代码很长或者有循环/递归的函数不适宜使用作为内联函数。  
（2）**inline对于编译器而言只是一个建议**，编译器会自动优化，如果定义为inline的函数体内有循环或递归等等，编译器优化时会忽略掉内联。  
（3）**inline不建议声明和定义分离，分离会导致链接错误**。因为添加了inline后函数被展开，没有函数地址，所以链接时编译器找不到函数。  
（4）**直接在类里面定义实现的成员函数默认是内联函数**。

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

## 3.与\#define的区别 ##

C语言为了避免简短的函数建立栈帧带来性能的消耗，提供宏，宏在预处理阶段展开，那么既然C语言已经解决了这个问题，为什么C++还要提供内联函数呢？

宏的优点：增强代码的复用性、提高性能。  
缺点：  
（1）不方便调试。（因为预编译阶段进行了替换）  
（2）代码可读性差，可维护性差，容易误用。  
（3）没有类型安全的检查 。

所以C++推荐把**频繁调用的小函数**定义成内联函数，在调用的地方展开时没有栈帧的开销。

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

# 三、auto关键字（C++11） #

## 1.概念 ##

早期C/C++中auto的含义：使用auto修饰的变量是具有自动存储器的局部变量。

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

代码如下（示例）：

double test()
    { 
    	return 10;
    }
    
    int main()
    { 
    	int a = 10;
    	auto b = a;//类型声明为auto，编译器可以自动根据a的类型推导b的类型
    	auto c = 'a';
    	auto d = test();
    
    	cout << typeid(b).name() << endl;
    	cout << typeid(c).name() << endl;
    	cout << typeid(d).name() << endl;
    
    	return 0;
    }

运行结果如下

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA_size_16_color_FFFFFF_t_70_pic_center 3]

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

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

## 2.使用注意事项 ##

### （1）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;
    	return 0;
    }

运行结果如下

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA_size_16_color_FFFFFF_t_70_pic_center 4]

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

### （2）在同一行定义多个变量 ###

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

auto a = 1, b = 2;//正确
    auto c = 10, d = 6.5;//编译不通过，因为c和d的类型不同

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

### （3）auto不能使用的场景 ###

**auto不能作为函数的形参且auto不能直接用来声明数组**

除此之外，下面两种写法也是不合法的：

auto e;//不合法，使用auto变量时必须对其初始化
    auto m = (auto*)malloc(sizeof(auto));//不合法

**auto在实际中最常见的优势用法就是跟以后会讲到的C++11提供的新式for循环等进行配合使用。**（下面会提到）

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

# 四、范围for（C++11） #

## 1.语法 ##

**遍历数组**更加简单，自动遍历。

代码如下（示例）：

int main()
    { 
    	int arr[] = {  1, 2, 3, 4, 5 };
    	for (auto e : arr)
    		cout << e << " ";
    	cout << endl << endl;
    	for (auto ee : arr)
    	{ 
    		ee *= 2;//注意这里不会改变arr数组内的值
    		cout << ee << " ";
    	}
    	cout << endl;
    	return 0;
    }

运行结果如下

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA_size_16_color_FFFFFF_t_70_pic_center 5]

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

## 2. 范围for的使用条件 ##

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

（2）对象的迭代器要能够实现++和==的操作。

（关于迭代器之后会提到）

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

# 五、nullptr（C++11） #

（1）在使用nullptr表示指针空值时，不需要包含头文件，nullptr是C++11作为新关键字引入的。  
（2）在C++11中，sizeof(nullptr) 与 sizeof((void\*)0)结果相同。  
（3）为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。

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

# 感谢阅读，如有错误请批评指正 #

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA_size_16_color_FFFFFF_t_70_pic_center]: /images/20210813/d8b74745bd014c8caa1fcfbdc384c3ac.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/20210706121246283.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20210706121522771.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/20210706122757858.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA_size_16_color_FFFFFF_t_70_pic_center 4]: https://img-blog.csdnimg.cn/20210706123306255.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA_size_16_color_FFFFFF_t_70_pic_center 5]: https://img-blog.csdnimg.cn/20210706130808964.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MTk4MzYwNA==,size_16,color_FFFFFF,t_70#pic_center