《C++学习笔记》-- 5. 引用的本质

5. 引用的本质

学习资源

引用的意义

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

swap 函数的实现对比

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

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

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

特殊的引用

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

int a = 4;

const int& b = a;

int* p = (int*)&b;

b = 5;  //Error，只读变量

*p = 5;  //Ok，修改变量 a 的值

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

const int& b = 1;  //Ok

int* p = (int*)&b;

b = 5;   // Error，只读变量

*p = 5;  // Ok，修改变量 a 的值

结论：

使用常量对 const 引用初始化后将生成一个只读变量！！！

• Q: 引用有自己的存储空间吗？

struct TRef
{
    char &r;
};

printf("sizeof(TRef) = %d\n", sizeof(TRef));

5-1.cpp

#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&) = %ld\n", sizeof(char &));
    printf("sizeof(rc) = %ld\n", sizeof(rc));

    printf("sizeof(TRef) = %ld\n", sizeof(TRef));
    printf("sizeof(ref.r) = %ld\n", sizeof(ref.r));
}

GUN g++ 编译运行输出

编译： g++ 5-1.cpp -o 5-1.out

运行： ./5-1.out

sizeof(char&) = 1
sizeof(rc) = 1
sizeof(TRef) = 8
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++ 为了实用性而隐藏了引用的存储空间这一细节

5-2.cpp

#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) = %ld\n", sizeof(r));
    printf("sizeof(r.before) = %ld\n", sizeof(r.before));
    printf("sizeof(r.after) = %ld\n", sizeof(r.after));
    
    printf("&r.before = %p\n", r.before);
    printf("&r.after = %p\n", r.after);

    return 0;
}

GUN g++ 编译运行输出

编译： g++ 5-2.cpp -o 5-2.out

运行：./5-2.out

sizeof(r) = 24
sizeof(r.before) = 8
sizeof(r.after) = 8
&r.before = 0x7ffc69da51a6
&r.after = 0x7ffc69da51a7

• C++ 中的引用旨在大多数情况下代替指针
  • 功能性：可以满足大多数需要使用指针的场合
  • 安全性：可以避开由于指针操作不当而带来的内存错误
  • 操作性：简单易用，有不失功能强大

5-3.cpp

#include <stdio.h>

int &demo() // ==> int* const
{
    int d = 0;

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

    return d; // ==> return &d;
}

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

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

    return 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;  // Error: rd 指向的内存已释放
    rs = 11;

    demo();
    func();

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

    return 0;
}

GUN g++ 编译运行输出

编译：g++ 5-3.cpp -o 5-3.out

运行：./5-3.out

demo: d = 0
func: s = 0

Segmentation fault

注意：

当函数 demo 调用结束后局部变量 d 被拥有的内存已被释放，rd 指向的内存无效

小结：

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