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

小程序：扫一扫查出行
【扫一扫了解最新限行尾号】
复制小程序

1.C++中的引用

(1)变量名的回顾

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

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

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

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

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

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

#include <stdio.h>int main()
{
//引用初探
int a = ;
int& b = a;//b为a的别名 b = ; //操作b就是操作a printf("a = %d\n", a); //
printf("b = %d\n", b); // printf("&a = %p\n", &a);
printf("&b = %p\n", &b);//&b等于&a
}

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

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

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

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

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

#include <stdio.h>void Example()
{
printf("Example:\n"); int a = ;
const int& b = a;//变量a的别名，const让变量b具有只读属性
int* p = (int*)&b; //&b就是变量a的地址 //b = 5;//非法，因为用const修饰的引用，其代表的变量是只读的 *p = ; //合法，修改变量a的值 printf("a = %d\n", a); //5;
printf("b = %d\n", b); //
}void Demo()
{
printf("Demo:\n"); //const引用
const int& c = ; //引用本应是变量的别名。一般，常量是不分配内存的。当编译器看
//该行时，会为常量1分配内存，并让c作为这段空间的别名。 int* p = (int*)&c; //c = 5;//非法，因为const修饰，c是只读的 *p = ;//合法，通过指针访问内存 printf("c = %d\n", c); // printf("\n", c); //5 //const修饰变量:注意与const引用的区别
const int a = ;
p = (int*)&a; //遇到&a才为常量分配内存 //a = 5;//非法，因为const修饰，a是只读的 *p = ;//合法，通过指针访问内存 printf("a = %d\n", a); //1，编译器看到a直接从符号表读其值（1）
printf("*p = %d\n", *p); //
}int main()
{
Example(); printf("\n"); Demo(); return ;
}

3.引用的本质

(1)引用在 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 ;
}

引用的存储空间

#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)); //
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); //after和before相差8个字节，中间隔了个b引用所占用的空间 return ;
}

4.引用的意义

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

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

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

函数返回引用

#include <stdio.h>int& demo()
{
int d = ; printf("demo: d = %d\n", d); //输出0 return d;//返回局部变量的引用，危险
}int& func()
{
static int s = ;
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 ;
}

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

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 = ;
const int& rx = x;//x与rx的类型相同，所以rx为只读变量,不能作为左值
//但本质上还是变量，引用x的内存值（而不是符号表中的值） int& nrx = const_cast<int&>(rx);//转为普通引用 nrx = ; //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 = ; //volatile修饰，分为y分配内存
int* p = const_cast<int*>(&y);//因y被const修饰，不能作为左值 *p = ; //因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 = ; printf("z = %d\n", z);//7，因z没进入符号表
printf("p = %p\n", p);//z的地址 return ;
}

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 = ;struct SV
{
int& x;
int& y;
int& z;
};int main()
{
int b = ;
int* pc = new int();

//将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 ;
}