【C++】引用的本质分析

声明：本文为听课笔记，课程为

https://item.taobao.com/item.htm?spm=a1z10.3-c.w4002-16326486319.21.2620ebfcFFOSQa&id=559166901112

（1）引用的意义

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

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

（2）交换函数实现对比

 ①传入指针：

#include <iostream>
#include <stdio.h>

void swap(int* a, int* b)
{
	int t = *a;
	*a = *b;
	*b = t;
}

int main()
{
	int a = 1;
	int b = 2;
	swap(&a, &b);
	printf("a = %d, b = %d\n", a, b);
	return 0;
}

编译运行：

②传引用：

#include <iostream>
#include <stdio.h>

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

int main()
{
	int a = 1;
	int b = 2;
	swap(a,b);
	printf("a = %d, b = %d\n", a, b);
	system("pause");
	return 0;
}

 

 发现输出的结果是一样的。

但是，传入引用这种方法更好一些，相当于直接传入值;而传指针这种方法，还需要将传入的值转换成地址，然后再传给指针。

（3）特殊的引用-const引用

特点：

1.在C ++中可以声明const的引用

2.const type＆name = var;

3.const引用让变量拥有只读属性

实例代码：

#include <iostream>
#include <stdio.h>

int main()
{
	int a = 4;
	const int& b = a;
	int* p = (int*)&b;
	b = 5; //Error,b是只读变量
	*p = 5; //OK,修改变量a的值
	system("pause");
	return 0;
}

编译运行：

可见，B是只读变量，但是可以通过* P指针修改一个的值。

 注意：当使用常量对常量引用进行初始化时，C ++编译器会为常量值分配空间，并将引用名作为这段空间的别名。

（4）实例分析：引用的特殊意义

实例代码：

#include <stdio.h>
#include <iostream>

void Example()
{
	printf("Example:\n");

	int a = 4;
	const int& b = a;
	int* p = (int*)&b;

	//b = 5;

	*p = 5;

	printf("a = %d\n", a);
	printf("b = %d\n", b);
}

void Demo()
{
	printf("Demo:\n");

	const int& c = 1;
	int* p = (int*)&c;

	//c = 5;

	*p = 5;

	printf("c = %d\n", c);
}

int main(int argc, char *argv[])
{
	Example();

	printf("\n");

	Demo();

	system("pause");
	return 0;
}

编译运行：

 

可见，引用只是 一个别名，可以通过指针修改它的值。

 

（5）引用有自己的存储空间吗?

我们看一段示例代码：

#include <stdio.h>

struct TRef
{
    char& r;
};

int main(int argc, char *argv[])
{ 
    char c = 'c';
    char& rc = c;
    TRef ref = { c };
    
    printf("sizeof(char&) = %d\n", sizeof(char&));
    printf("sizeof(rc) = %d\n", sizeof(rc));
    
    printf("sizeof(TRef) = %d\n", sizeof(TRef));
    printf("sizeof(ref.r) = %d\n", sizeof(ref.r));

    return 0;
}

编译运行：

 

可见结构体TRef占用4个字节。

（6）引用在C++中的内部实现是一个指针常量（它的本质是指针）

注意：

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

2.从使用的角度，引用只是一个别名，C++为了实用性而隐         藏了引用的储存空间这一细节

 编程实验：引用的存储空间

#include <stdio.h>
#include <iostream>
struct TRef
{
	char* before;
	char& ref;
	char* after;
};

int main(int argc, char* argv[])
{
	char a = 'a';
	char& b = a;
	char c = 'c';

	TRef r = { &a, b, &c };

	printf("sizeof(r) = %d\n", sizeof(r));
	printf("sizeof(r.before) = %d\n", sizeof(r.before));
	printf("sizeof(r.after) = %d\n", sizeof(r.after));
	printf("&r.before = %p\n", &r.before);
	printf("&r.after = %p\n", &r.after);

	system("pause");
	return 0;
}

 编译运行：

可见，    char& ref 占用了4个字节，说明了引用的本质就是指针，指针占用4个字节

 

（7）引用的意义

C++中的引用旨在大多数的情况下代替指针：

1.功能性：可以满足多数需要使用指针的场合

2.安全性：可以避开由于指针操作不当而带来的内存错误

3.操作性：简单易用，又不失功能性

 （8）实例分析：函数返回引用

#include <stdio.h>
#include <iostream>
int& demo()
{
	int d = 0;

	printf("demo: d = %d\n", d);

	return d;
}

int& func()
{
	static int s = 0;

	printf("func: s = %d\n", s);

	return s;
}

int main(int argc, char* argv[])
{
	int& rd = demo();
	int& rs = func();

	printf("\n");
	printf("main: rd = %d\n", rd);
	printf("main: rs = %d\n", rs);
	printf("\n");

	rd = 10;
	rs = 11;

	demo();
	func();

	printf("\n");
	printf("main: rd = %d\n", rd);
	printf("main: rs = %d\n", rs);
	printf("\n");

	system("pause");
	return 0;
}

编译运行：

然而，此时会出现一个警告：

 说明，不能返回一个局部变量的引用，并且在输出的是一个随机值，说明此时是一个野指针。而static int s = 0;可以返回s，是因为static的局部变量在全局上分配空间。

（9）总结

1.引用作为变量别名而存在旨在代替指针

2.const引用可以使得变量具有只读属性

3.引用在编译器内部使用指针常量实现

4.引用的最终本质为指针

5.引用可以尽可能的避开内存错误

<全文完>