【C++】引用是什么意思？

原创已于 2024-01-19 14:22:23 修改 · 337 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #c语言

于 2023-11-11 21:42:19 首次发布

C++ 专栏收录该内容

7 篇文章

订阅专栏

本文详细解析了C++中的引用概念、语法、特性，以及引用与指针的区别。同时讨论了内联函数的原理、优点和使用场景，以及宏的优缺点及其替代方法。

1.引用

1.1引用的概念

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

比如三国杀中的“麴义”，玩家们取了个亲切的外号叫“白马”。还有“荀彧”，有的玩家叫不认识字就取个外号叫“苟或”、“熏鱼”。

1.2语法

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

1.3引用特性

1. 引用在定义时必须初始化
2. 一个变量可以有多个引用（一个对象可以有多个别名，可以给别名继续取别名）
3. 引用一旦引用一个实体，再不能引用其他实体（Java引用可以改变指向，C++引用不能改变指向，尤其是数据结构不能脱离指针）

int main()
{
	int a = 0;
	// 引用必须初始化
	int& b = a;
	//int& b;//err

	int& c = a;
	int d = 1;

	c = d;
	//一个变量可以有多个别名
	int& e = a;
	int& f = e;
	return 0;
}

1.4常引用

常引用就是在引用类型前面用 const 来进行修饰；和 const 修饰变量一样，被 const 修饰的引用只能够读（const不能修改，别名也不能修改。），而不能够写，即不能修改引用变量的值；

1.本质：权限的放大（只存在于引用），可以缩小，可以平移，但是不能放大

2.引用和指针存在权限的放大

3.int 和double，类型转换产生临时变量，临时变量具有常性（不能修改，所以加const）

int main()
{
	int rwa = 10;
	int& rwa2 = rwa;
	const int& ra = rwa;

	const int& rb = 10;
	//int& rwb = rb;//权限被放大了就会报错
	const int& rb2 = rb;
}

分析：rwa的权限是读写，rwa2的权限也是读写，但是ra的权限只是读；很明显，rwa2是权限平移，ra的权限相较于a是缩小的；同样的rb的权限只是读，rwb的权限是读写相较于rb的权限是放大的所以编译器会报错，rb2的权限是读和rb的权限一样也就是平移。

对常量的引用

int main()
{
	//int& rwc = 10;//编译器会报错
	const int& rc = 10;
	return 0;
}

分析：我们知道，数字10只存在于指令中，在内存中并不占用空间，当我们用引用对其进行引用时，10会先赋值给一个临时变量，我们对这个临时变量进行引用；而临时变量具有常性，即临时变量是只读的，所以我们需要用常引用来引用这个临时变量。

对不同类型的变量进行引用：

int main()
{
	double rwd = 10.11;
	//int& rwd2 = rwd;//编译器会报错	
	const int& rd3 = rwd;
	printf("%p\n%p\n", &rwd, &rd3);
	cout << rd3 << endl;
	return 0;
}

运行结果：

分析：当引用类型和变量的类型不一致的时候，double类型的rwd会先赋值给一个临时变量，临时变量截断。rd3引用的就是这个截断的临时变量。由于临时变量有常性，因此要用const修饰int&，以防权限扩大。

1.5 使用场景

1.5.1.做参数

void Swap(int& left, int& right)
{
    int temp = left;
    left = right;
    right = temp;
}

在Swap函数中，使用引用参数，形参的改变改变实参（引用的核心价值是做参数，形参的改变改变实参，提高效率）。

补充：在单链表中，尾插要改变*pphead的值，我们可以把二级指针改为一级指针加上引用的方式。但是当我们把SListNode中的next指针也设计为引用，因为尾节点next是不断改变的，而引用一旦引用了一个实体就不能再引用其他实体，这也从侧面说明了引用不能代替指针，只能简化指针。

常引用做参数：

当我们想使用引用提高效率，又担心原数据不小心被修改，我们便可以使用常引用；在CPP中，一般情况下非输出类型的参数都是常引用参数。

1.5.2.作返回值

传值返回：

int Count()
{
	int n = 0;
	n++;

	return n;
}

int main()
{
	int ret = Count();
	return 0;
}

传值返回时，返回值会先创建一个临时变量，n赋值给这个临时变量，这个临时变量再赋值给ret。用static修饰后，这个n会放在静态区，就算Count函数运行完销毁了，n也不会受到影响。当没有static修饰，n是存放在栈中的，当Count函数运行完之后，函数栈帧销毁，这个n也随之被销毁。

因此在传值拷贝中，不管n有没有被销毁，n都能把原来的值赋值给ret。

内存空间被销毁还是可以用，但是是属于越界访问

被销毁就存在两种情况：

1.这个空间没有被及时清理，n值还在里面没有变。（和女朋友分手了，有可能前女友心里还有自己，找她复合有很大机会成功）

2.这个空间被清理了，n的值就是随机值了。（和女朋友分手了，前女友心里可能没有自己，心理想的是别人，找她复合有几率成功但是很小）

1.5.3传引用返回：

int& 传引用返回，返回n的别名，结果不确定会不会把这个空间清理了。

返回n的别名给ret 不能用引用作返回，

传引用返回，返回值是n的别名，可以理解为中间变量也是n的别名。当我们用static修饰n的时候，n被存放在静态区，不会随着Count函数的销毁而销毁，n原来的值还是可以赋值给ret

时间一去不复返，空间可以重复利用，不同函数也可以调同一块空间。

本质：出了作用域，返回对象就销了，不能用引用返回，否则结果是不确定的，局部的静态成员变量只会被初始化一次。

还有一种情况使用不同的空间：

这种情况的时候，c没有被static修饰，c会被放在栈帧中，当Add运行完后，栈帧会被销毁，那么原本存放c的空间是否还是存放的c原来的值就不得而知了。

结论：

1.出了作用域，返回变量不存在了，不能用引用返回，因为引用返回的结果是未定义的。

2.出了作用域，返回变量存在，才能用引用返回。

引用返回的作用：

1.引用返回提高效率，减少了一次数据拷贝，节省了空间，提高效率。

2.修改返回对象。直接返回变量本身，从而通过修改返回值修改变量。

修改返回对象：

#include<assert.h>
typedef struct SeqList
{
	int a[100];
	int size;
}SL;

void SLModify(SL* ps, int pos, int x)
{
	//...
	assert(ps);
	assert(pos < ps->size);
	ps->a[pos] = x;
}

//引用做返回值：可以修改返回对象
int& SLat(SL* ps, int pos)
{
	assert(ps);
	assert(pos < ps->size);
	
	return ps->a[pos];
}

int main()
{
	SL s;
	//...
	SLat(&s, 3) = 10;

	for (size_t i = 0; i < s.size; i++)
	{
		SLat(&s, i)++;
	}

	return 0;
}

1.5.4. 传值、传引用效率比较

以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。

1.5.4.1值和引用作为参数的性能比较

#include <time.h>
struct A { int a[10000]; };

void TestFunc1(A aa) {}

void TestFunc2(A& aa) {}

void TestRefAndValue()
{
	A a;
	// 以值作为函数参数
	size_t begin1 = clock();
	for (size_t i = 0; i < 10000; ++i)
		TestFunc1(a);
	size_t end1 = clock();

	// 以引用作为函数参数
	size_t begin2 = clock();
	for (size_t i = 0; i < 10000; ++i)
		TestFunc2(a);
	size_t end2 = clock();

	// 分别计算两个函数运行结束后的时间
	cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
	cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}

int main()
{
	TestRefAndValue();

	return 0;
}

运行结果：

1.5.4.2值和引用作为返回值类型性能比较

#include <time.h>

A a;
// 值返回
A TestFunc1() { return a; }
// 引用返回
A& TestFunc2() { return a; }

void TestReturnByRefOrValue()
{
	// 以值作为函数的返回值类型
	size_t begin1 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc1();
	size_t end1 = clock();

	// 以引用作为函数的返回值类型
	size_t begin2 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc2();
	size_t end2 = clock();

	// 计算两个函数运算完成之后的时间
	cout << "TestFunc1 time:" << end1 - begin1 << endl;
	cout << "TestFunc2 time:" << end2 - begin2 << endl;
}

运行结果：

通过上述代码的比较，发现传值和指针在作为传参以及返回值类型上效率相差很大。

1.5.5.引用和指针的区别：

语法：引用没有开空间。指针开了空间存地址，在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。

在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

我们来看下引用和指针的汇编代码对比：

结论：引用底层是用汇编实现的。

引用还有其他不同的点（使用和概念上），引用相对安全。记得去理解。

1. 引用概念上定义一个变量的别名，指针存储一个变量地址。
2. 引用在定义时必须初始化，指针没有要求
3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
4. 没有NULL引用，但有NULL指针
5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小

7. 有多级指针，但是没有多级引用
8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
9. 引用比指针使用起来相对更安全

2.宏

#define ADD(x, y) ((x) + (y))

宏的优缺点：

优点：

                1.增强代码的复用性。

                2.提高性能。

        缺点：
        1、容易出错，语法细节多
        2、不能调试
        3、没有类型安全的检查

int main()
{
	//写好了建议替换看一看
	int ret1 = Add(1, 3) * 5;
	cout << ret1 << endl;

	int a = 1, b = 2;
	int ret2 = Add(a | b, a & b);
	//int ret2 = Add(a | b + a & b);

	return 0;
}

CPP中有哪些技术替代宏？

1. 常量定义换用const enum
2. 短小函数定义换用内联函数

3.内联函数

3.1概念：

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

如果在上述函数前增加inline关键字将其改成内联函数，在编译期间编译器会用函数体替换函数的调用。

查看方式：

1. 在release模式下，查看编译器生成的汇编代码中是否存在call Add
2. 在debug模式下，需要对编译器进行设置，否则不会展开(因为debug模式下，编译器默认不会对代码进行优化

3.2特性：

1. inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运
行效率。
2. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建
议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不
是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。下图为
《C++prime》第五版关于inline的建议：

3. inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址
了，链接就会找不到。
// F.h
#include <iostream>
using namespace std;

inline void f(int i);

// F.cpp
#include "F.h"
void f(int i)
{
    cout << i << endl;
}

// main.cpp
#include "F.h"
int main()
{
    f(10);
    return 0;
}

// 链接错误