C++深度解析教程学习笔记（2）C++中的引用

(1)变量名的回顾

①变量是一段实际连续存储空间的别名,程序中通过变量来申请并命名存储空间

②通过变量的名字可以使用存储空间。(变量的名字就是变量的值,&变量名是取地址操作)

(2)C++中新增加了引用的概念

①引用可以看作一个己定义变量的别名

②引用的语法:Type& name = var; //Type 为类型名,name 为引用的名字,var为己定义的变量名

③普通引用在定义时必须用同类型的变量进行初始化,函数参数引用的初始化发生在函数被调用时。

#include <stdio.h>

int main()
{
    //引用初探
    int a = 4;
    int& b = a;//b为a的别名

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

    printf("a = %d\n", a); //5
    printf("b = %d\n", b); //5

    printf("&a = %p\n", &a);
    printf("&b = %p\n", &b);//&b等于&a
}

(3)引用作为变量别名而存在,因此在一些场合可以代替指针

(4)引用相对于指针来说,具有更好的可读性和实用性

C++深度解析教程学习笔记（2）C++中的引用

2.特殊的引用——const引用

(1)const Type& name = var; //让变量拥有只读属性

(2)当使用常量对 const 引用进行初始化时,C++编译器会为这个常量值分配空间,并将引用名作为这段空间的别名。但这样用常量对 const 引用初始化将生成的是一个只读变量。

#include <stdio.h>

void Example()
{
    printf("Example:\n");

    int a = 4;
    const int& b = a;//变量a的别名，const让变量b具有只读属性
    int* p = (int*)&b; //&b就是变量a的地址

    //b = 5;//非法，因为用const修饰的引用，其代表的变量是只读的

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

    printf("a = %d\n", a); //5;
    printf("b = %d\n", b); //5
}

void Demo()
{
    printf("Demo:\n");

    //const引用
    const int& c = 1; //引用本应是变量的别名。一般，常量是不分配内存的。当编译器看
    //该行时，会为常量1分配内存，并让c作为这段空间的别名。

    int* p = (int*)&c;

    //c = 5;//非法，因为const修饰，c是只读的

    *p = 5;//合法，通过指针访问内存

    printf("c = %d\n", c); //5

    printf("\n", c); //5

    //const修饰变量:注意与const引用的区别
    const int a = 1;
    p = (int*)&a; //遇到&a才为常量分配内存

    //a = 5;//非法，因为const修饰，a是只读的

    *p = 5;//合法，通过指针访问内存

    printf("a = %d\n", a); //1，编译器看到a直接从符号表读其值（1）
    printf("*p = %d\n", *p); //5
}

int main()
{
    Example();

    printf("\n");

    Demo();

    return 0;
}

3.引用的本质

(1)引用在 C++中的内部实现是一个常量指针,因此引用所占用的空间大小与指针相同。

C++深度解析教程学习笔记（2）C++中的引用

(2)从使用的角度,引用只是一个别名,C++为了实用性而隐藏了引用的存储空间这一细节。

①在编译过程中,编译器看到 int& a 的声明就会转换为 int* const a;

②看到使用引用时,会转为*a,如此隐藏了使用指针的事实。

#include <stdio.h>

struct TRef
{
    char& r;//引用的本质是常量指针，因此会分配4字节的空间，相当于char* const r;
};



int main()
{
    char c = 'c';
    char& rc = c;
    TRef ref = { c };

    printf("sizeof(char&) = %d\n", sizeof(char&));//1，char型变量别名，大小为1
    printf("sizeof(rc) = %d\n", sizeof(rc));      //1，变量c的别名，大小为1

    printf("sizeof(TRef) = %d\n", sizeof(TRef));  //结构体内有个引用，本质为指针，占4字节
    printf("sizeof(ref.r)= %d\n", sizeof(ref.r)); //1，char型变量的别名，大小为1


    return 0;
}

引用的存储空间

#include <stdio.h>

struct TRef
{
    char* before; //4字节
    char& ref;//4字节，本质是常量指针，会分配4字节的空间，相当于char* const ref;
    char* after;//4字节

};



int main()
{
    char a = 'a';
    char& b = a;
    char c = 'c';

    TRef r = { &a, b, &c };

    printf("sizeof(r) = %d\n", sizeof(r));               //12
    printf("sizeof(r.before) = %d\n", sizeof(r.before)); //4
    printf("sizeof(r.after)  = %d\n", sizeof(r.after));  //4
    printf("&r.before = %p\n", &r.before);
    printf("&r.after  = %p\n", &r.after); //after和before相差8个字节，中间隔了个b引用所占用的空间

    return 0;
}

4.引用的意义

(1)功能性:引用在大多数情况下代替指针,可以满足需要使用指针的场合

(2)安全性:可以避开由于指针操作不当而带来的内存错误

(3)操作性:简单易用,又不失功能强大

函数返回引用

#include <stdio.h>

int& demo()
{
    int d = 0;

    printf("demo: d = %d\n", d); //输出0

    return d;//返回局部变量的引用，危险
}

int& func()
{
    static int s = 0;
    printf("func: s = %d\n", s);//输出0

    return s; //合法，返回的是静态局部变量（位于全局存储区中的）
}



int main()
{
    int& rd = demo();
    int& rs = func();

    printf("\n");
    printf("main: rd = %d\n", rd);//垃圾数值
    printf("main: rs = %d\n", rs);//0，返回全局存储区中的s
    printf("\n");

    return 0;     
}

引用作为变量别名而存在,旨在代替指针，引用在编译器内部使用常量指针实现,其最终本质为指针，引用可以尽可能的避开内存错误。

5.关于const的疑问

(1)const 常量的判别准则

①只有用字面量初始化的 const 常量才会进入符号表,如 const int i = 1;

②使用其它变量初始化的 const 常量仍然是只读变量。如 const int a = b;//a 为只读变量

③被 volatile 修饰的 const 常量不会进入符号表,如 volatile const int i = 1;//这时会为 i 分配内存,且 i 每次都是从内存中取值。加 const 只是说明 i 不能作为左值。

▲在编译期间不能直接确定初始值的 const 标识符,都被作为只读变量处理。

(2)const 引用的类型与初始化变量的类型

①当用变量来初始化与 const 引用时,如果两者类型相同,则初始化变量成为只读变量。

②当用变量来初始化与 const 引用时,如果两者类型不同,则将生成一个新的变量,即引用的是另一个新变量,而不是原来的用来初始化引用的那个变量。

#include <stdio.h>

int main()
{
    //实验1：初始化变量的类型与引用类型相同时
    const int x = 1;
    const int& rx = x;//x与rx的类型相同，所以rx为只读变量,不能作为左值
                      //但本质上还是变量，引用x的内存值（而不是符号表中的值）

    int& nrx = const_cast<int&>(rx);//转为普通引用

    nrx = 5;  //nrx与rx都引用了x的内存值

    printf("x = %d\n", x);     //1，从符号表中读取
    printf("rx = %d\n", rx);   //5，从内存中读取
    printf("nrx = %d\n", nrx); //5，从内存中读取

    printf("&x = %d\n", &x);
    printf("&rx = %d\n",&rx);
    printf("&nrx = %d\n",&nrx); //x、rx、nrx地址相同

    //实验2：初始化变量的类型与引用类型不同时
    char c = 'c';
    char& rc =c;
    const int& trc = c;//c与trc类型不一致，则会生成一个新的变量，然后trc引用这个新的变量
    
    rc = 'a';

    printf("c = %c\n", c);  //c
    printf("rc = %c\n",rc); //c
    printf("trc = %c\n",trc);//a

    printf("&c = %p\n", &c); 
    printf("&rc = %p\n",&rc); //rc与c的地址相同
    printf("&trc = %p\n",&trc);//trc是一个新的地址

    //实验3：volatlie
    volatile const int y = 2; //volatile修饰，分为y分配内存
    int* p = const_cast<int*>(&y);//因y被const修饰，不能作为左值

    *p = 6; //因y不能作为左值，用来代替y = 6;这样的写法

    printf("y = %d\n", y);//6，volatile指示y得从内存中读取
    printf("p = %p\n", p);//y的地址

    const int z = y; //用变量初始化const常量，z不会进入符号表，z分配内存

    p = const_cast<int*>(&z);
    
    *p = 7;

    printf("z = %d\n", z);//7，因z没进入符号表
    printf("p = %p\n", p);//z的地址

    return 0;
}

6.关于引用的疑问

(1)指针与引用的不同

	指针	引用
初始化	值是一个内存地址，不需要初始化	必须在定义时初始化，之后无法代表其它变量
访问内存	通过指针可以访问对应内存地址中的值	对引用的操作（赋值，取地址等）都会传递到其代表的变量上。
const修饰	被const修饰成常量或只读变量。如const int* p;//p	const引用，表示其代表的变量具有只读属性。如，const int& a等价于const int* const a;

(2)从使用 C++语言的角度来看,引用与指针没有任何关系。引用是变量的新名字,操作引用就是操作对应的变量。当进行 C++编程时,直接站在使用的角度看待引用,与指针毫无关系,引用就是变量的别名。

(3)从 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各成员初始化为变量a,b,*pc等内存的引用
    SV sv = {a, b, *pc};
    printf("&sv.x = %p\n", &sv.x);//变量a的地址，全局区
    printf("&sv.y = %p\n", &sv.y); //变量b的地址，栈
    printf("&sv.z = %p\n",&sv.z);   //new出来的地址，堆

    //在C++中没有“引用数组”的概念，请看如下分析
    //对于数组而言，其内存是连续分布的。当进行&array[1] - &array[0]
    //表示前后两个元素的地址相差的值，应等于sizeof(元素的类型)。
    //但如果允许定义“引用数组”的话，如下面语句，&array[1]表示第1个元素
    //的地址，即元素b的地址(&b)，而&array[0]表示&a，显然这两个地址是不连续的。
    //所以int& array[]={a, b, *pc};//这样的定义是错误的，C++里不支持“引用数组”

    return 0;
}