引用的意义

• 引用作为变量别名而存在，因此在一些场合可以替代指针
• 引用相对于指针来说具有更好的可读性和实用性

swap 函数实现对比：

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

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

注意： 函数中的引用形参不需要进行初始化！！

特殊的引用

• const 引用

  • 在 C++ 中可以声明 const 引用
  • const TyPE* name = VAR;
  • const 引用让变量拥有只读属性

void code()
{
    int a = 4;
    const int& b = a;
    int* p = (int*)&b;
    
    b = 5;   // Error, 只读变量
    
    *p = 5;  // Ok, 修改变量 a 的值
}

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

void code()
{
    const int& b = 1;
    int* p = (int*)&b;
    
    b = 5;   // Error, 只读变量
    
    *p = 5;  // Ok, 修改变量 b 的值
}

结论： 使用常量对 const 引用初始化后将生成一个只读变量。

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

#include <stdio.h>

void code_1()
{
    printf("code_1: n");
    
    int a = 4;
    const int& b = a;
    int* p = (int*)&b;
    
    // b = 5;  // ERROR
    
    *p = 5;
    
    printf("a = %dn", a);
    printf("b = %dn", b);
}

void code_2()
{
    printf("code_2:n");
    
    const int& c = 1;
    int* p = (int*)&c;
    
    // c = 5;  // ERROR
    
    *p = 5;
    
    printf("c = %dn", c);
}

int main()
{
    code_1();
    
    printf("n");
    
    code_2();
    
    return 0;
}

输出：
code_1: 
a = 5
b = 5

code_2:
c = 5

思考： 引用有自己的存储空间吗？

void code()
{
    struct TRef
    {
        char& r;
    };
    
    printf("sizeof(TRef) = %dn", sizeof(TRef));
}

编程实验： 引用的思考

#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&) = %dn", sizeof(char&));  // ==> sizeof(char)
    printf("sizeof(rc) = %dn", sizeof(rc));
    
    printf("sizeof(TRef) = %dn", sizeof(TRef));    // 注意这里!
    printf("sizeof(ref) = %dn", sizeof(ref));      // 注意这里!
    printf("sizeof(ref.r) = %dn", sizeof(ref.r));
    
    return 0;
}

输出：
sizeof(char&) = 1
sizeof(rc) = 1
sizeof(TRef) = 4
sizeof(ref) = 4
sizeof(ref.r) = 1

引用的本质

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

Type& name; <==> Type* const name;

void f(int& a)
{
    a = 5;
}

void f(int* const a)
{
    *a = 5;
}

注意：

1. C++ 编译器在编译过程中使用常量指针作为引用的内部实现，因此引用所占用的内存空间与指针相同。
2. 从使用的角度，引用只是一个别名，C++ 为了实用性而隐藏了引用的存储空间这一细节。

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

#include <stdio.h>

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) = %dn", sizeof(r));
    printf("sizeof(r.before) = %dn", sizeof(r.before));
    printf("sizeof(r.after) = %dn", sizeof(r.after));
    printf("&r.before = %pn", &r.before);
    printf("&r.after = %pn", &r.after);
    
    return 0;
}

输出：
sizeof(r) = 12
sizeof(r.before) = 4
sizeof(r.after) = 4
&r.before = 0xbfd5a7cc
&r.after = 0xbfd5a7d4

引用的意义

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

  • 功能性：可以满足多数需要使用指针的场合
  • 安全性：可以一定程度避开由于指针操作不当带来的内存错误
  • 操作性： 简单易用，又不失强大功能

实例分析： 函数返回引用

#include <stdio.h>

int& code_1()    // int* const
{
    int d = 0;
    
    printf("code_1: d = %dn", d);
    
    return d;   // return &d
}

int& code_2()   // int* const
{
    static int s = 0;
    
    printf("code_2: %dn", s);
    
    return s;   // return &s
}

int main(int argc, char* argv[])
{
    int& rd = code_1();
    int& rs = code_2();
    
    printf("n");
    printf("main: rd = %dn", rd);
    printf("main: rs = %dn", rs);
    printf("n");
    
    rd = 10;
    rs = 11;
    
    code_1();
    code_2();
    
    printf("n");
    printf("main: rd = %dn", rd);
    printf("main: rs = %dn", rs);
    printf("n");
    
    return 0;
}

编译输出：
warning: reference to local variable ‘d’ returned

运行输出：
code_1: d = 0
code_2: 0

main: rd = 8937460
main: rs = 0

code_1: d = 0
code_2: 11

main: rd = 8937460
main: rs = 11

引用不能完全避免内存操作带来的错误！

小结

• 引用作为变量别名而存在旨在代替指针
• const 引用可以使得变量具有只读属性
• 引用在编译器内部使用常量指针实现
• 引用的最终本质为指针
• 引用可以尽可能的避开内存错误

以上内容参考狄泰软件学院系列课程，请大家保护原创！