关于引用的疑问

1.变量名回顾

• 变量是一段实际连续存储空间的别名
• 程序中通过变量来申请并命名存储空间
• 通过变量的名字可以使用存储空间

问题：

一段连续的存储空间只能有一个别名吗？

2.c++中引用

• 引用可以看作一个已定义变量的别名
• 语法 Type& name = var；

int a = 4;
int& b = a; //b为a的别名

b = 5; //操作b就是操作a

注意：普通引用在定义时必须用同类型的变量进行初始化

3.c++对三目运算符做了什么？

• 当三目运算符的可能返回都是变量时，返回的是变量引用
• 当三目运算符的可能返回中有常量时，返回的是值

int a = 1;
int b = 2;

(a < b ? a : b) = 3;//正确，返回a或b的引用，可作为左值 
(a < b ? 1 : b) = 3;//错误，返回1或b的值，不能作为左值

4.引用的意义

• 引用作为变量别名而存在，因此在一些场合可以替代指针
• 引用相对于指针来说有更好的可读性和实用性
• 注意：函数中的形参不需要进行初始化

5.特殊的引用

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引用初始化后将生成一个只读变量

6.引用有自己的存储空间吗？

#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\n", sizeof(char&));
    printf("sizeof(rc) = %d\n", sizeof(rc));
    
    printf("sizeof(TRef) = %d\n", sizeof(TRef));
    printf("sizeof(ref.r) = %d\n", sizeof(ref.r));

    return 0;
}

/*
sizeof(char&) = 1
sizeof(rc) = 1
sizeof(TRef) = 4
sizeof(ref.r) = 1
*/

7.引用的本质

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

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

注意：

c++编译器在编译过程中用指针常量作为引用的内部实现，因此引用所占用的空间大小与指针相同

从使用的角度，引用只是一个别名，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) = %d\n", sizeof(r));
    printf("sizeof(r.before) = %d\n", sizeof(r.before));
    printf("sizeof(r.after) = %d\n", sizeof(r.after));
    printf("&r.before = %p\n", &r.before);
    printf("&r.after = %p\n", &r.after);

    return 0;
}
/*
sizeof(r) = 12
sizeof(r.before) = 4
sizeof(r.after) = 4
&r.before = 0xbf84d43c
&r.after = 0xbf84d444
*/

8.函数引用的返回

#include <stdio.h>

//返回局部变量d的引用，函数调用结束，这个变量就被销毁
int& demo()
{
    int d = 0;
    
    printf("demo: d = %d\n", d);
    
    return d; 
}

//返回静态局部变量s的引用。一直存在
int& func()
{
    static int s = 0;
    
    printf("func: s = %d\n", s);
    
    return s;
}

int main(int argc, char* argv[])
{
    int& rd = demo();//rd是局部变量d的引用
    int& rs = func();//rs是静态局部变量s的引用
    
    printf("\n");
    printf("main: rd = %d\n", rd);//demo()函数调用结束 局部变量d就被摧毁了，rd就相当于一个野指针
    printf("main: rs = %d\n", rs);//func调用结束，静态局部变量s不会消失，rs是合法的
    printf("\n");
    
    rd = 10;//相当于给一个野指针赋值
    rs = 11;//操作rs就是操作s
    
    demo();//0
    func();//11
    
    printf("\n");
    printf("main: rd = %d\n", rd);
    printf("main: rs = %d\n", rs);
    printf("\n");
    
    return 0;
}

demo: d = 0
func: s = 0

main: rd = 14335988
main: rs = 0

demo: d = 0
func: s = 11

main: rd = 14335988
main: rs = 11

9.引用和指针什么关系？如何理解“引用的本质就是指针常量”

指针是一个变量

• 值为一个内存地址，不需要初始化，可以保存不同的地址
• 通过指针可以访问对应内存地址中的值
• 指针可以被const修饰成常量或者只读变量

引用只是一个变量的新名字

• 对引用的操作(赋值，取地址等)都会传递到代表的变量上
• const引用使其代表的变量具有只读属性
• 引用必须在定义时初始化，之后无法代表其他变量

从使用c++的角度来看

• 引用和指针没有任何的关系
• 引用是变量的新名字，操作引用就是操作对应的变量

从c++编译器角度来看

• 为了支持新概念“引用”必须有一个有效的解决方案
• 在编译器内部，使用指针常量来实现“引用”
• 因此"引用"在定义时必须初始化

​​​​​​​在工程项目开发中

• 当进行c++编程时，直接站在使用的角度看待引用，与指针毫无关系，引用就是变量的别名。
• 当对c++代码进行调试分析时，一些特殊情况，可以考虑站在c++编译器的角度看待引用

#include <stdio.h>

int a = 1;

struct SV
{
    int& x;
    int& y;
    int& z;
};

int main()
{
    int b = 2;
    int* pc = new int(3);
    SV sv = {a, b, *pc};
    //数组是一片连续的内存空间
    int& array[] = {a, b, *pc}; // &array[1] - &array[0] = ?  Expected ==> 4
    
    printf("&sv.x = %p\n", &sv.x);
    printf("&sv.y = %p\n", &sv.y);
    printf("&sv.z = %p\n", &sv.z);
    
    delete pc;
    
    return 0;
}

​​​​​​​小结

• 指针是一个变量
• 引用是一个变量的新名字
• const引用能够生成新的只读变量
• 在编译器内部使用指针常量实现引用
• 编译器不能直接确定初始值的const标识符都是只读变量​​​​​​​