C++数据类型 — 引用的理解与应用

目录

 

C++的“引用”详解

引用作为函数的返回值

参数的引用来传值

常量引用

引用的意义

引用的本质

---

 

C++的“引用”详解

 

本质：一块内存，有两个名字；

定义方式如下：

       类型名 &引用名 = 同类型的某变量名;

此种写法就定义了一个某种类型的引用，并将其初始化为引用某个同类型的变量。“引用名”的命名规则和普通变量相同。

int n;
int & r = n;

1. r就是一个引用，也可以说 r 的类型是 int &。第二条语句使得 r 引用了变量 n，也可以说 r 成为了 n 的引用。某个变量的引用和这个变量是一回事，相当于该变量的一个别名。
2. 注意：定义引用时一定要将其初始化，否则编译无法通过。通常会用某个变量去初始化引用，初始化后，它就一直引用该变量，不会再引用别的变量。
3. 也可以用一个引用去初始化另一个引用，这样两个引用就引用同一个变量。不能用常量初始化引用，也不能用表达式初始化引用（除非该表达式的返回值是某个变量的引用）。总之，引用只能引用变量。

类型为 T& 的引用和类型为 T 的变量是完全兼容的，可以互相赋值。如下：

#include <iostream>
using namespace std;
int main()
{
	int n = 4;
	int & r = n;  //r引用了n，从此r和n是一回事
	r = 4; //修改r就是修改n
	cout << r << endl;  //输出4
	cout << n << endl;  //输出4

	n = 5;              //修改n就是修改r
	cout << r << endl;  //输出 5

	int & r2 = r;         //r2和r引用同一个变量,就是n
	cout << r2 << endl; //输出 5
	return 0;
}

引用作为函数的返回值

#include <iostream>
using namespace std;

int n = 4;

int & SetValue()
{
	return n;  //返回对n的引用
}

int main()
{
    SetValue() = 40; //返回值是引用的函数调用表达式，可以作为左值使用，可以理解为“int &n = 40;”
    //SetValue 函数返回对 n 的引用，因此对 SetValue 函数的返回值进行赋值，
    //就是对 n 进行赋值，结果就是使得 n 的值变为 40。
    cout << n << endl;  //输出40
 
    int & r = SetValue();//表达式 SetValue 函数的返回值是 n 的引用，
    //因此可以用来初始化 r，其结果就 是 r 也成为 n 的引用。可以理解为“int &r = n;”
    cout << r << endl;  //输出40
    return 0;
}

引用作为函数的返回值，其用途会在“运算符重载”和“标准模板库”中有着更广阔的用途。

 

参数的引用来传值

        在 C++ 中，函数参数的传递有两种方式：传值和传引用。在函数的形参不是引用的情况下，参数传递方式是传值的。传引用的方式要求函数的形参是引用。

“传值”是指，函数的形参是实参的一个拷贝，在函数执行的过程中，形参的改变不会影响实参。

#include <iostream>
using namespace std;
void Swap(int a, int b) //参数传值：形参是实参的拷贝；
{
	int tmp;
	//以下三行将a、b值互换
	tmp = a;
	a = b;
	b = tmp;
	cout << "In Swap: a = " << a << " b = " << b << endl;
}
int main()
{
	int a = 4, b = 5;
	Swap(a, b);
	cout << "After swaping: a = " << a << " b = " << b << endl; //输出：4,5
	return 0;
}

        如果函数的形参是引用，那么参数的传递方式就是传引用的。在传引用方式下，形参是对应的实参的引用。也就是说，形参和对应的实参是一回事，形参的改变会影响实参。

#include<iostream>
using namespace std;
void Swap(int & a, int & b)
{ //交换a、b的值
	int tmp;
	tmp = a; a = b; b = tmp;
}
int main()
{
	int n1 = 100, n2 = 50;
	Swap(n1, n2);  //n1、n2 的值被交换
	cout << n1 << " " << n2 << endl;  //输出 50 100
}

常量引用

定义引用时，可以在前面加 const 关键字，则该引用就成为“常引用”。如：

int n;
const int & r = n; //定义了常引用 r，其类型是 const int &。

常引用和普通引用的区别在于：不能通过常引用去修改其引用的内容。注意，不是常引用所引用的内容不能被修改，只是不能通过常引用去修改而已，但可以用别的办法修改。如下代码所示：

int n = 100;
const int & r = n;
r = 200;  //编译出错，不能通过常引用修改其引用的内容
n = 300;  //没问题，n的值变为300

       注意，const T& 和 T& 是不同的类型。T& 类型的引用或 T 类型的变量可以用来初始化 const T & 类型的引用，const T 类型的常变量和 const T & 类型的引用则不能用来初始化 T & 类型的引用，除非进行强制类型转换。例如下面的程序：

void Func(char & r) { }
void Func2(const char & r) { }
int main()
{
	const char cc = 'a';
	char c;
	const char & rcc = cc;
	const char & rc = c;  //char变量可以用来初始化 const char & 的引用

	char & r = cc;  //编译出错，const char 类型的常变量不能用来初始化 char & 类型的引用
	char & r2 = (char &)cc;  //没问题，强制类型转换
	
	Func(rcc);  //编译出错，参数类型不匹配
	Func2(rcc);  //没问题，参数类型匹配
	return 0;
}

引用的意义

1）引用作为其它变量的别名而存在，因此在一些场合可以代替指针

2）引用相对于指针来说具有更好的可读性和实用性

 

引用的本质

概述：

1）引用在C++中的内部实现是一个常指针

Type& name 等价于 Type* const name

2）C++编译器在编译过程中使用常指针作为引用的内部实现，因此引用所占用的空间大小与指针相同。

3）从使用的角度，引用会让人误会其只是一个别名，没有自己的存储空间。这是C++为了实用性而做出的细节隐藏，引用的那个量也占用存储空间，就如同指针一样。

证明引用本质是常量：

#include<iostream>
using namespace std;

int main()
{
	int a = 10;
	int &b = a;
	b = 11; //重新赋值 

	printf("a=%d\n", a);
	printf("b=%d\n", b);
	printf("a的地址:%x\n", &a);
	printf("&的地址:%x\n", &b); 

	return 0;
}
/*单独定义的引用时，必须初始化；说明很像一个常量
输出：
a=11
b=11
a的地址:6dfe98
&的地址:6dfe98 
*/

证明引用也占用存储空间，并且大小和指针一样：

#include<iostream>
using namespace std;

struct Student {
	int &x;
};
struct Teacer {
	int &a;
	int &b;
};
int main()
{
	printf("sizeof(Student): %d\n", sizeof(Student));
	printf("sizeof(Teacher): %d\n", sizeof(Teacer));
	system("pause");
	return 0;
}
/*输出：(跟指针神似) 
sizeof(Student): 4
sizeof(Teacher): 8
*/