c++指针与引用的总结

素颜马尾好姑娘i 2022-03-26 13:06 249阅读 0赞

**指针是引用吗？？？？**

在回答这个问题之前先来看看什么是引用☟☟☟

**引用不是定义一个新的变量，而是给一个已经定义的变量重新起一个别名。**  
![b是a的引用][b_a]  
引用需要注意的特点：

*  一个变量可取多个别名（引用）
 *  引用必须初始化（类型& 引用变量名=已定义的变量名）
 *  引用只能在初始化时引用一次，不能再引用其他变量

#include<iostream>
    using namespace std;
    int main()
    { 
    	int a = 1;
    	int &b = a;
    	cout << "a.address is " << &a << endl;
    	cout << "b.address is " << &b << endl;
    
    	b = 2;
    	cout << "a is " << a << endl;
    	cout << "b is " << b << endl;
    	system("pause");
    	return 0;
    }

![输出结果][20190117121447539.png]  
根据输出结果我们发现b和a指向同一块儿空间，b能修改a的值，也就是我们上面所说的**别名**。

**引用被const修饰时**

int main()
    { 
    	const int a = 10;
    	//int &b = a;//报错！因为类型不匹配，常量无法强转为变量！
    	const int &b = a;
    	cout << "a.address is " << &a << endl;
    	cout << "b.address is " << &b << endl;
    
    	int c = 2;
    	const int &d = c;//可强转
    	c = 3;
    	//d = 4;//不能修改常量值
    	cout << "c is " << c << endl;
    	cout << "d is " << d << endl;
    
    	system("pause");
    	return 0;
    }

![输出结果][20190117123704773.png]  
我们发现：

1.  常量只能转为常量，不能转为变量，且常量不能被修改
2.  变量可以转为常量，当变量改变时，常量引用也随之改变

**引用的各种类型相互转换**

int main()
    { 
    	int a = 10;
    	double b = a;
    	//double &b = a;//报错！
    	cout << "a.address is " << &a << endl;
    	cout << "b.address is " << &b << endl;
    	cout << "a is " << a << endl;
    	cout << "b is " << b << endl;
    
    	const double c = a;
    	const double &d = a;
    	cout << "c is " << c << endl;
    	cout << "d is " << d << endl;
    
    	system("pause");
    	return 0;
    }

![输出结果][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pvY2hlYmVkNjY2_size_16_color_FFFFFF_t_70]  
我们发现：

*  a和b地址不一样，所以为赋值
 *  double &b = a;报错！这是因为**a赋值给b时要生成一个带有常性的临时变量，所以不能赋值**
 *  也就是说，后面的c和d都为赋值而非引用，不同的是，c被a赋值，d被a的临时变量赋值。

**引用作参数**

void Swap(int left, int right)
    { 
    	int temp = left;
    	left = right;
    	right = temp;
    }
    int main()
    { 
    	int a = 10;
    	int b = 20;
    	Swap(a, b);
    	cout << "a is " << a << endl;
    	cout << "b is " << b << endl;
    	system("pause");
    	return 0;
    }

![a和b无法交换][a_b]  
这是因为函数调用参数压栈过程中，形参将在栈上做**临时拷贝**，当函数调用结束，释放栈帧，形参也随之释放，就算在函数中修改了形参的值，也对实参没有影响！  
所以我们在学习指针时是这样传参的：

void Swap(int *left, int *right)
    { 
    	int temp = *left;
    	*left = *right;
    	*right = temp;
    }
    int main()
    { 
    	int a = 10;
    	int b = 20;
    	Swap(&a, &b);
    	cout << "a is " << a << endl;
    	cout << "b is " << b << endl;
    	system("pause");
    	return 0;
    }

![a和b交换了][a_b 1]  
我们用指针的指向去修改我们要修改的内容！  
而今天我们用引用：

void Swap(int &left, int &right)
    { 
    	int temp = left;
    	left = right;
    	right = temp;
    }
    int main()
    { 
    	int a = 10;
    	int b = 20;
    	Swap(a, b);
    	cout << "a is " << a << endl;
    	cout << "b is " << b << endl;
    	system("pause");
    	return 0;
    }

![a和b交换了][a_b 2]  
我们发现a和b也交换了，但是却比指针简单的多！而且我们发现因为形参是实参的别名，我们不需要开辟临时空间存储临时变量，减少了拷贝对象，相当于通过自身交换实现。

总结：

*  传参时若要对参数进行修改，需要传指针或引用
 *  传指针时需要为形参**拷贝临时空间**，而引用不需要，引用传“本身”
 *  引用和指针在底层的实现**都是使用指针指向**
 *  经过多次测试发现，在处理极大的数据时，**传引用比传指针效率高**
 *  当不希望函数内改变参数x的值时，尽量使用常引用传参

**引用作返回值**

int& Add(int d1, int d2)
    { 
    	int ret = d1 + d2;
    	return ret;
    }
    int main()
    { 
    	int a = 3, b = 4;
    	int &c = Add(a, b);
    	cout << "c:" << c << endl;
    	system("pause");
    	return 0;
    }

![c=7][c_7]  
**c==7？？？**  
我们来看函数栈帧：  
![函数调用栈帧][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pvY2hlYmVkNjY2_size_16_color_FFFFFF_t_70 1]  
我们发现在ret返回时Add()的函数栈帧将释放，而ret是局部变量，将随着栈帧的销毁而销毁，**但**我们的引用c任然指向ret释放的那块儿空间，那块儿空间随时都会被申请占用，所以我们的“c=7”是偶然啦~

总结：

1.  不要返回一个临时变量的引用
2.  如果返回对象出了当前函数的作用域依然存在，则最好使用引用返回，这样更高效

**大总结**  
回到我们最开始，指针是引用吗？显然不是。

*  引用只能在定义时初始化一次，之后不能改变指向其它变量（从一而终）；指针变量的值可变。
 *  引用必须指向有效的变量，指针可以为空。
 *  sizeof指针对象和引用对象的意义不一样。sizeof引用得到的是所指向的变量的大小，而sizeof指针是对象地址的大小。
 *  指针和引用自增(++)自减(–)意义不一样。
 *  相对而言，引用比指针更安全。
 *  指针比引用更灵活，但是也更危险。使用指针时一定要注意检查指针是否为空。指针所指的地址释放以后最好置0，否则可能存在野指针  
    问题。

[b_a]: /images/20220326/30f905ebfcd943a1a665b8c12697865d.png
[20190117121447539.png]: /images/20220326/92ab00b4e03e452f9d5965ee2ed31f03.png
[20190117123704773.png]: /images/20220326/b857d76d6ede45499050699236454d0e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pvY2hlYmVkNjY2_size_16_color_FFFFFF_t_70]: /images/20220326/6fab1d5414fe4c598f558120c98dc2e4.png
[a_b]: /images/20220326/77d47583b7ff481b8bffb126e0930318.png
[a_b 1]: /images/20220326/a5d98e96bed849f3afa327f22b6d1775.png
[a_b 2]: /images/20220326/f080c633c67540718b33a331cc8d4366.png
[c_7]: /images/20220326/e28eecdfe553437e82070a436024c29f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0pvY2hlYmVkNjY2_size_16_color_FFFFFF_t_70 1]: /images/20220326/796605f70fb04b30b8ba18172c184c37.png