【C++】引用机制深度解析

1. 引用

1.1 引用概念

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

比如：李逵，在家称为"铁牛"，江湖上人称"黑旋风"

类型& 引用变量名（对象名） = 引用实体；

ra 是 a 的引用，引用也就是别名，a 再取了一个名字 ra

void TestRef() 
{     
    int a = 10;     
    int& ra = a;//<====定义引用类型    
    printf("%p\n", &a);     
    printf("%p\n", &ra); 
}

注意：引用类型必须和引用实体是同种类型的

1.2 引用特性

1. 引用在定义时必须初始化

2. 一个变量可以有多个引用

3. 引用一旦引用一个实体，再不能引用其他实体

void TestRef() 
{    
    int a = 10;    
    // int& ra;   // 该条语句编译时会出错,没有初始化   
    int& ra = a;    
    int& rra = a;    
    printf("%p %p %p\n", &a, &ra, &rra);   
}

1.3 常引用

void TestConstRef() 
{     
//a被const修饰，只读
const int a = 10;     
//int& ra = a;   // 该语句编译时会出错，a为常量     
const int& ra = a;    
// int& b = 10; // 该语句编译时会出错，b为常量     
const int& b = 10;     
double d = 12.34;    
//int& rd = d; // 该语句编译时会出错，类型不同     
const double& rd = d; 
int c = 1;
const int& e = c;//可以
}

总结：引用取别名时，变量的访问权限可以缩小不能放大

1.4 使用场景

1.4.1 做参数

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

void swap_cpp(int& c, int& d)
{
        int temp = c;
        c = d;
        d = temp;
}

int main()
{
        int a = 0;
        int b = 1;
        swap(&a, &b);
        swap_cpp(a, b);
        return 0;
}

这里都可以交换 a，b，void swap_cpp（int& c， int& d）这里的 c，d 是对 a，b 的引用，c 和 a 的地址是一样的；

1.4.2 作返回值

传值返回会多创建一个临时空间,因为传回的是返回值的拷贝；

但是传引用返回返回的是变量的别名，不会多创建空间；

传值都会产生拷贝

凡是临时变量都具有常性

下面代码输出结果是 7 为什么？

int& Add(int a, int b) 
{     
    int c = a + b;     
    return c; 
} 
int main() 
{     
    int& ret = Add(1, 2);     
    Add(3, 4);     
    cout << "Add(1, 2) is :"<< ret <<endl;     
    return 0; 
}

（这个一定要留意）注意：如果函数返回时，出了函数作用域，如果返回对象还在（还没还给系统），则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。

函数返回栈帧销毁，空间还在，但是空间的使用权变了，意味着这块空间可以被其他函数或变量修改；

Static int c = a + b;只会执行一次，第二次 a，b 的值改变也不会执行这段代码了；c 静态修饰后还是同一个 c，空间的地址不变

static 修饰的变量不受其他函数变量的影响（即不能被随意改变）

1.5 传值、传引用效率比较

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

#include <iostream>
using namespace std;//C++库中的所有东西都是放到std命名空间中
#include <time.h> 
struct A { int a[10000]; };
void TestFunc1(A a) {}

void TestFunc2(A& a) {}

int main()
{
    A a;
    // 以值作为函数参数      
    size_t begin1 = clock();
    for (size_t i = 0; i < 100000; ++i)
        TestFunc1(a);
    size_t end1 = clock();
    // 以引用作为函数参数      
    size_t begin2 = clock();
    for (size_t i = 0; i < 100000; ++i)
        TestFunc2(a);
    size_t end2 = clock();
    // 分别计算两个函数运行结束后的时间      
    cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
    cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;

    return 0;
}

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

#include <iostream>
using namespace std;//C++库中的所有东西都是放到std命名空间中
#include <time.h> 
struct A { int a[10000]; };
A a;
// 值返回 
A TestFunc1() { return a; }
// 引用返回 
A& TestFunc2() { return a; }

int main()
{
    // 以值作为函数的返回值类型 
    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;

    return 0;
}

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

1.7 引用和指针的区别

在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。

int main() 
{ 
    int a = 10; 
    int& ra = a; 
    cout<<"&a = "<<&a<<endl; 
    cout<<"&ra = "<<&ra<<endl; 
    return 0; 
}

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

int main() 
{ 
    int a = 10; 
    
    int& ra = a; 
    ra = 20; 
    
    int* pa = &a; 
    *pa = 20; 
    
    return 0; 
}

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

引用和指针的不同点：

1. 引用概念上定义一个变量的别名，指针存储一个变量地址。

2. 引用在定义时必须初始化，指针没有要求

3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何

一个同类型实体

4. 没有 NULL 引用，但有 NULL 指针

5. 在 sizeof 中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数（32

位平台下占 4 个字节）

6. 引用自加即引用的实体增加 1，指针自加即指针向后偏移一个类型的大小

7. 有多级指针，但是没有多级引用

8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理

9. 引用比指针使用起来相对更安全