C++基础(下)---引用详解,基于范围的for循环(C++11),指针空值nullptr(C++11)

本文链接：https://blog.youkuaiyun.com/wang_yiduo/article/details/89712332

本文详细介绍了C++中的引用，包括引用的使用、特性及应用场景，强调了引用与指针的区别。接着讲解了C++11引入的基于范围的for循环，简化了遍历数组或集合的过程，并指出其使用条件。最后，文章讨论了指针空值 nullptr 的优势，以及如何避免使用 NULL 的潜在问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

引用

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

-引用的使用:

类型& 引用变量名(对象名) = 引用实体;

代码演示:
```
#include<iostream>

using std::cout;
using std::endl;

int main()
{
	int a = 1;
	int& b = a;
	cout << &a << endl;
	cout << &b << endl;
}
```
输出结果为:

结论:可以看出他们的地址是相同的,b只是a的别名

-引用特性
1. 引用在定义时必须初始化
2. 一个变量可以有多个引用
3. 引用一旦引用一个实体，再不能引用其他实体
代码演示:
```
#include<iostream>

using std::cout;
using std::endl;

int main()
{
	int a = 1;
	int d = 2;
	//int& b;因为没有初始化,所以该条语句编译的时候会报错
	int& b = a;
	int& c = a;//一个变量可以有多个引用
	//int& c = d;引用一旦引用一个实体，再不能引用其他实体,所以该条语句编译的时候会报错
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
}
```
输出结果为:1,1,1

-常引用

代码演示:
```
#include<iostream>

using std::cout;
using std::endl;

int main()
{
	const int a = 1;
	//int& b = a;a是常量,所以不能再改动,必须要声明b也是常量
	const int& b = a;
	const int& c=10;
}
```
-引用使用场景
1. 做参数
  
  代码演示:
```
#include<iostream>

using std::cout;
using std::endl;

void swap(int& a, int& b)
{
	int tmp = a;
	a = b;
	b = tmp;
}

int main()
{
	int a = 1;
	int b = 2;
	swap(a, b);
	cout << "a=" << a << endl << "b=" << b << endl;
}
```
  输出结果为:a=2,b=1;
2. 做返回值
  
  代码演示:
```
#include<iostream>

using std::cout;
using std::endl;

int& Add(int a,int b)
{
	int sum = a + b;
	return sum;
}

int main()
{
	int& c = Add(1, 2);
	cout << "c=" << c << endl;
}
```
  输出结果为:a=3
  
  注意:在使用引用做返回值的时候可能会出现意想不到的结果,代码演示:
```
#include<iostream>

using std::cout;
using std::endl;

int& Add(int a, int b)
{
	int c = a + b;
	return c;
}

int main()
{
	int& ret = Add(1, 2);
	Add(2, 2);
	cout << "ret=" << ret << endl;
}
```
  输出结果为:ret=4
  
  注意:这里为什么c=4而不是3呢?因为再返回sum后,给函数Add在栈上开辟的空间会销毁掉,但是c是一个引用,它代表的是给Add函数在栈上开辟的的那块儿空间,虽然Add销毁了,但是那块儿空间还存在,这时再将Add(2,2)压栈压进去,此时c代表的空间里面存的内容就是Add(2,2),不再是Add(1,2),如图所示:
  
  结论：如果函数返回时，离开函数作用域后，其栈上空间已经还给系统，因此不能用栈上的空间作为引用类型返回。如果以引用类型返回，返回值的生命周期必须不受函数的限制(即比函数生命周期长)。
-引用和指针的比较
- 共性:
  在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间,但是在底层实现上实际是有空间的，因为引用是按照指针方式来实现的
  
  如图所示:
- 不同点:
  - 引用在定义时必须初始化，指针没有要求
  - 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
  - 没有NULL引用，但有NULL指针
  - 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占 4个字节)
  - 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
  - 有多级指针，但是没有多级引用
  - 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
  - 引用比指针使用起来相对更安全

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

范围for的语法

在C++98中如果要遍历一个数组，可以按照以下方式进行：
```
void Founc()
{
	int arr[] = { 1, 2, 3, 4, 5 };
	int size = sizeof(arr) / sizeof(arr[0]);
	for (int i = 0; i < size; ++i)
		printf("%d", arr[i]);
	for (int* p = arr; p < arr + size; ++p)
		printf("%d", *p);
}
```
对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

代码演示:
```
#include<iostream>

using std::cout;
using std::endl;

int main()
{
	int arr[] = { 1, 2, 3, 4, 5 };
	for (auto a : arr)
		cout << a << endl;
}
```
输出结果为1,2,3,4,5
范围for的使用条件

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

注意：以下代码就有问题，因为for的范围不确定
```
void Founc(int arr[])
{
	for(auto a:arr)
		cout<<a<<endl;
}
```
注意:范围for也因此限制了不能倒着或者随机从数组中取值

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

C++98中的指针空值

在良好的C/C++编程习惯中，声明一个变量时好给该变量一个合适的初始值，否则可能会出现不可预料的错误，比如未初始化的指针。如果一个指针没有合法的指向，我们基本都是按照如下方式对其进行初始化：

void Founc()
{
	int* p=NULL;
	int* p1=0;
}

注意:上面的两种写法启示意义是相同的,因为NULL实际上是一个宏,被定义为0,在<stddef,h>中做出如下定义:

#ifndef NULL
#ifdef __cplusplus
#define NULL    0
#else
#define NULL    ((void*)0)
#endif
#endif

可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void)的常量*。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦，比如：

#include<iostream>

using std::cout;
using std::endl;

void f(int)
{
	cout << "f(int)" << endl;
}

void f(int*)
{
	cout << "f(int*)" << endl;
}

int main()
{
	f(0);
	f(NULL);
	f((int*)NULL);
}

输出结果为:
在这里插入图片描述
程序本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，因此此时就会出现必须要将NULL强制转换的问题,为了克服这个问题于是就引出了C++11的nullptr这个关键字

代码演示:

#include<iostream>
#include<stdlib.h>

using std::cout;
using std::endl;

void f(int)
{
	cout << "f(int)" << endl;
}

void f(int*)
{
	cout << "f(int*)" << endl;
}

int main()
{
	f(nullptr);
}