资讯

历史

科技

环境与自然

成长

游戏

财经

文学与艺术

美食

健康

家居

文化

情感

汽车

三农

军事

旅行

运动

教育

生活

星座命理

C++引用机制详解：概念、特性与实战

创作时间:

作者:

@小白创作中心

C++引用机制详解：概念、特性与实战

引用

CSDN

https://blog.csdn.net/2301_80955819/article/details/141113265

前言

在C语言中，指针是一种功能强大的数据类型，允许直接访问和操作内存。然而，使用不当容易出错。C++引入了引用这一概念，它实现了部分类似指针的功能，但更加安全、简洁。

一、引用的概念和定义

引用是C++中的一种特殊别名机制。定义引用时，并不是创建了一个新变量，而是给原有的变量起了一个别名。其定义方式如下：

(数据类型)& 引用名 = 引用对象;

代码示例：

#include <iostream>
using namespace std;
int main()
{
    int a = 0;
    int& b = a; // 定义引用，给a取了一个别名
    a++;
    cout << b << endl;
    
    b++;
    cout << a << endl;
    return 0;
}

运行结果：

可以看到，无论是对a自增，还是对b自增，它们表示的值都会发生改变。我们再来打印一下它们的地址：

cout << &a << endl;
cout << &b << endl;

结果显示它们的地址是相同的。这表明引用只是给变量起了一个别名，表示的还是同一块内存空间。

二、引用的特性

引用有以下三点语法特性：

引用在定义的时候必须表明它所表示的对象。
由于引用是用作给变量取别名，所以一个变量可以有多个引用。当然，引用也可以有引用。
引用一旦指定了对象，就不能再指定其他对象。

三、引用的实用性

了解了引用的概念和特性之后，我们不禁会发出疑问：既然要对变量进行操作，直接修改不就好了嘛，何必还要取一个别名呢？

1. 引用传参

举一个例子：

#include <iostream>
using namespace std;
void Swap(int& x, int& y)
{
    int tmp = x;
    x = y;
    y = tmp;
}
int main()
{
    int a = 3;
    int b = 5;
    Swap(a, b); // 交换a和b的值
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    return 0;
}

运行结果：

可以看到，使用引用传参，通过函数交换了变量a和b的值。由于引用是给变量起别名，所以此时的x和y就表示a和b本身。因此，我们在函数内部就实现了这两个元素的交换。相比传址调用，它的写法更加简单，并且在语法层面，引用是不开辟新内存的，减少了拷贝，节省了内存空间。

2. 引用做返回值

2.1 引用做返回值的作用

首先来看一段代码：

#include <iostream>
using namespace std;
int fun()
{
    static int a = 10;
    return a;
}
int main()
{
    fun()++; // 报错
    cout << fun() << endl;
    return 0;
}

很显然，以上代码是不可行的。函数的返回值是一个临时变量，而临时变量具有常性，我们无法对这个值进行修改。但是引用做返回值可以做到这一点：

#include <iostream>
using namespace std;
int& fun()
{
    static int a = 10;
    return a;
}
int main()
{
    fun()++;
    cout << fun() << endl;
    return 0;
}

我们将返回值改成int的引用类型，则此时函数返回静态变量a的别名，所以我们让它自增，就相当于改变了a的值。

有了引用做返回值，我们在调用函数的时候就可以通过这个返回值直接访问和修改原始对象，并且避免了临时变量的拷贝，增加程序运行的效率。

2.2 引用坍缩问题、悬挂引用问题

刚才引用做返回值的方法虽然好用，但是难免会出现一些问题。举个例子：

#include <iostream>
using namespace std;
int& func1()
{
    static int a = 0;
    return a;
}
int main()
{
    int x = func(); // 这里应该是func1
    return 0;
}

虽然这里的func1函数返回了a的引用，但是我们却在主函数中以一个整形变量来接收，这里就会发生一种隐式的类型转换--引用坍缩，编译器会将这个返回值转换为它所引用的对象的一个临时拷贝，这将导致我们无法访问并修改a的值，达不到预期效果。所以一定要以相同类型的引用来接收引用返回值。

再举一个例子：

#include <iostream>
using namespace std;
int& func2()
{
    int a = 0;
    return a;
}
int main()
{
    int& x = func(); // 这里应该是func2
    return 0;
}

在func2函数中，我们创建了一个局部变量a并且返回它的引用，但是由于a是一个局部变量，当函数栈帧销毁时，变量a的空间已经被释放了，此时的返回值就变成一个悬挂引用（野引用），也就是说这个引用的主体已经不存在了，程序的运行结果就是未定义的。所以我们在使用引用做返回值时，一定要注意返回后的引用主体是否还存在。

四、const修饰引用

我们在定义引用时，可以在变量名之前加上const修饰（称之为常引用）。当一个引用被const修饰时，该引用就无法修改其所表示的对象。例如：

#include <iostream>
using namespace std;
int main()
{
    int a = 0;
    const int& b = a;
    a = 10;
    b = 20; // 报错
    return 0;
}

注意：对于一个被const修饰的变量，定义它的引用时也需要用const修饰。例如：

#include <iostream>
using namespace std;
int main()
{
    const int a = 0;
    int& b = a; // 报错
    const int& c = a; // 正确
    return 0;
}

对于以下情况，定义引用时也必须要用const修饰：

#include <iostream>
using namespace std;
int main()
{
    int a = 5;
    const int& b = a * 3; // a*3是一个临时对象，具有常性，它的引用要用const修饰
    float c = 5.5f;
    const int& d = c; // 当引用和对象的类型不同时，由于隐式类型转换的结果是一个临时对象，定义引用也需要用const修饰
    return 0;
}