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

指针是一个变量,而引用是一个变量的新名字。const 引用能够生成新的只读变量,编译时不能直接确定初始值的 const 标识符都是只读变量。