引用的意义

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

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 引用可以使得变量具有只读属性
  • 引用在编译器内部使用常量指针实现
  • 引用的最终本质为指针
  • 引用可以尽可能的避开内存错误

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

本文固定链接: http://www.js-code.com/cpp/cpp_60162.html