4 引用的本质

目录

• 1 引用的意义
• 2 特殊的引用
• 3 引用的本质

1 引用的意义

• 引用作为变量别名而存在，因此在一些场合可以代替指针

• 引用相对于指针来说具有更好的可读性和实用性

• 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;
  }
  

• 注意：函数中的引用形参不需要初始化，它的初始化发生在函数调用的时候

2 特殊的引用

• const 引用

  • 在 C++ 中可以声明 const 引用

  • const Type& name = var;

  • conts 引用让变量拥有只读属性

    int a = 4;
    const int& b = a;
    int* p = (int*)&b;  //等价于对变量a取地址
    
    b = 5;  //error: assignment of read-only reference 'b'
    *p = 5;  //正确，修改变量a的值
    

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

  const int& b = 1;
  
  int* p = (int*)&b;
  
  b = 5;  //error: assignment of read-only reference 'b'
  *p = 5;  //正确: 修改变量a的值
  

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

• 问题：引用有自己的存储空间么？

  • 有！

  • Demo

    #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&) = %d
    ", sizeof(char&));  //1
        printf("sizeof(rc) = %d
    ", sizeof(rc));  //=> sizeof(c) = 1
        
        printf("sizeof(TRef) = %d
    ", sizeof(TRef));  //0?
        printf("sizeof(ref.r) = %d
    ", sizeof(ref.r));  //=> sizeof(c) = 1
    
        return 0;
    }
    

  • 运行结果

    sizeof(char&) = 1
    sizeof(rc) = 1
    sizeof(TRef) = 4
    sizeof(ref.f) = 1
    

3 引用的本质

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

  Tyep& name;
  void f(int& a)
  {
      a = 5;
  }
  
  //等价于
  Type* const name;
  void f(int* const a)
  {
      *a = 5;
  }
  

• 注意

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

• 引用的存储空间

  • Demo

    #include <stdio.h>
    
    struct TRef
    {
        char* before;
        char& ref;
        char* after;
    };
    
    int main(int argc, char* argv[])
    {
        char a = 'a';
        char& b = a;  //1）取变量a的地址 2）将a的地址赋值给b对应的4个字节的内存空间中去
        char c = 'c';
    
        TRef r = {&a, b, &c};
    
        printf("sizeof(r) = %d
    ", sizeof(r));
        printf("sizeof(r.before) = %d
    ", sizeof(r.before));
        printf("sizeof(r.after) = %d
    ", sizeof(r.after));
        printf("&r.before = %p
    ", &r.before);
        printf("&r.after = %p
    ", &r.after);
    
        return 0;
    }
    

  • 编译运行

    sizeof(r) = 12
    sizeof(r.before) = 4
    sizeof(r.after) = 4
    &r.before = 0xbf8a300c
    &r.after = 0xbf8a3014
    

• 函数引用返回：返回局部变量的引用/指针可能会造成内存泄漏

  • Demo

    #include <stdio.h>
    
    int& demo()
    {
        int d = 0;
        
        printf("demo: d = %d
    ", d);
        
        return d;  //error: 返回局部变量的引用 <=> return &d
    }
    
    int& func()
    {
        static int s = 0;
        
        printf("func: s = %d
    ", s);
        
        return s;  //返回静态局部变量 => 正确，静态变量不会随着函数调用的返回而被摧毁
    }
    
    int main(int argc, char* argv[])
    {
        int& rd = demo();
        int& rs = func();
        
        printf("
    ");
        printf("main: rd = %d
    ", rd);
        printf("main: rs = %d
    ", rs);
        printf("
    ");
        
        rd = 10;
        rs = 11;
        
        demo();
        func();
        
        printf("
    ");
        printf("main: rd = %d
    ", rd);
        printf("main: rs = %d
    ", rs);
        printf("
    ");
        
        return 0;
    }
    

  • 编译

    test.cpp: In function ‘int& demo()’:
    test.cpp:5:9: warning: reference to local variable ‘d’ returned [-Wreturn-local-addr]
         int d = 0;
             ^
    

  • 运行

    demo: d = 0
    func: s = 0
    
    main: rd = 13209588  <=>rd 等价于一个野指针
    main: rs = 0
    
    demo: d = 0
    func: s = 11
    
    main: rd = 132095588
    main: rs = 11