c引用详解
铺垫:
变量名实质上是一段连续存储空间的别名,是一个标号
程序中通过变量来申请并命名内存空间
通过变量的名字可以使用存储空间
(能不能再名字的基础上在起个名字?)
概念:
1) 可以看做一个已定义变量的别名
引用是c++的语法范畴,不能再用c语言的思想去思考问题(间接修改)
属于c++编译器对c的扩展
引用做函数参数
普通引用在声明时必须用其他的变量进行初始化
引用作为函数参数声明时不进行初始化#include using namespace std; //引用基本用法 void main() { int a = 10; int &b = a; b = 100; printf(＂b:%d ＂, b); printf(＂a:%d ＂, a); cout << ＂hello....＂ << endl; system(＂pause＂); return; } void main11() { int a = 10; int &b = a; //int &c; //普通引用必须要初始化 system(＂pause＂); } void myswap01(int a, int b) { int c = 0; c = a; a = b; b = c; } void myswap02(int *a,int *b) { int c = 0; c = *a; *a = *b; *b = c; } void myswap03(int &a, int &b) { int c = 0; c = a; a = b; b = c; } void main() { int x, y; x = 10; y = 20; myswap01(x, y); printf(＂x:%d,y:%d ＂, x, y); myswap02(&x, &y); printf(＂x:%d,y:%d ＂, x, y); myswap03(x, y); printf(＂x:%d,y:%d ＂, x, y); system(＂pause＂); } //复杂数据类型 的引用 struct Teacher { char name[64]; int age; }; void printfT(Teacher *pT) { cout << pT->age << endl; } //pT是t1的别名,相当于修改了t1 void printfT2(Teacher &pT) { cout << pT.age << endl; } //pT和t1是两个不同的变量 void printfT3(Teacher pT) { cout << pT.age << endl; pT.age=45;//只会修改pT变量,不会修改t1变量 } void main() { Teacher t1; t1.age = 35; printfT(&t1); printfT2(t1);//pT是t1的别名 printfT3(t1);//pT是形参,t1拷贝了一份数据,给pT printf(＂t1.age:%d ＂,t1.age); cout << ＂hello....＂ << endl; system(＂pause＂); return; }
引用的意义
引用作为其他指针变量的别名而存在,因此在一些场合可以替代指针
引用相对于指针来说具有更好的可读性和实用性
引用的本质
c++编译器背后做了什么工作
单独定义的时候必须初始化--->很像常量
1)引用在c++内部实现是一个常指针
2)c++编译器在编译过程中使用常指针作为引用的内部实现,因此引用所占的空间与指针相同
3)从使用的角度,引用会让人误会其只是一个别名,没有自己的储存空间,这是c++为了实用性做出的细节隐藏.
结论 :当我们使用引用的语法时,我们不用去关心编译器引用是怎么做了
当我们分析奇怪的语法现象时,才去考虑编译器是怎么做的#include using namespace std; void main01() { const int c1 = 10; int a = 10; int &b = a;//像常量 printf(＂&a:%d ＂, &a); printf(＂&b:%d ＂, &b);//a b就是同一块内存空间的门牌号 依附于这个内存空间 cout << ＂hello..＂ << endl; system(＂pause＂); return; } //普通引用有自己的空间吗?-->有,和指针所占的一样 struct Teacher { char name[64];//64 int age;//4 int &a;//4 int &b;//4 }; //引用的本质一个常量指针 void main() { printf(＂sizeof(Teacher):%d ＂, sizeof(Teacher); system(＂pause＂); } void modifyA(int &a1) { a1 = 100; } void modifyA2(int* const a1) { *a1 = 10;//*实参的地址,去间接修改实参的值 } void main() { int a = 10; modifyA(a);//指向这个函数调用的时候,我们程序员不需要取a的地址 printf(＂a:%d ＂, a); modifyA2(&a);//如果是指针 需要我们手工去取实参地址 printf(＂sizeof(Teacher):%d ＂, sizeof(Teacher)); system(＂pause＂); } //间接赋值 //间接赋值成立的三个条件 /* 1 定义2个变量 2 建立关系 实参取地址传给形参 3 形参间接修改实参的值 */ void modifyA3(int *p) { *p = 190;//3 } void main() { int a = 10; int *p = NULL; //1 p = &a; *p = 100; { *p = 200; } modifyA3(&a);//2 } //引用是间接赋值哪几个条件的组合? 2编译器做了 //1 23后2个条件写在一起了 只不过2编译器做了
函数返回值是引用(引用当左值)
c++引用使用时的难点:
当函数返回值为引用时,
若返回栈变量 ,不能成为其他引用的初始值,不能作为左值使用
若返回静态变量或全局变量 可以成为其他引用的初始值.
即可作为右值使用,也可作为左值使用#include using namespace std; int getAA1() { int a; a = 10; return a; } //返回a的本身 int& getAA2() { int a; a = 10; return a; } int* getAA3() { int a; a = 10; return &a; } void main01() { int a1 = 0; int a2 = 0; a1 = getAA1(); a2 = getAA2(); int &a3= getAA2(); printf(＂a1:%d ＂, a1); printf(＂a2:%d ＂, a2); printf(＂a3:%d ＂, a3); cout << ＂hello..＂ << endl; system(＂pause＂); return; } //返回静态/全局 int j() { static int a = 10; a++; return a; } int &j() { static int a = 10; a++; return a; } void main() { int a1 = 10; int a2 = 20; a1 = j1(); a2 = j2(); int &a3 = j2(); printf(＂a1:%d ＂, a1); printf(＂a2:%d ＂, a2); printf(＂a3:%d ＂, a3); cout << ＂hello..＂ << endl; system(＂pause＂); return; } //函数当左值 //返回变量的值 int g() { static int a = 10; a++; return a; } //返回变量本身 int &g() { static int a = 10; a++; return a; } void main() { //g1() = 100;//执行这个,函数返回值就是11.不成立err g2() = 100;//把上面的函数改成了100,所以这个就成立 system(＂pause＂); }
指针的引用#include using namespace std; struct Teacher { char name[64]; int age; }; int getTeacher(Teacher **p) { Teacher *tmp = NULL; if (p == NULL) { return -1; } tmp = (Teacher*)malloc(sizeof(Teacher)); if (tmp == NULL) { return -2; } p->age = 33; *p = tmp; } //指针的引用做函数参数 int getTeacher2(Teacher* &myp) {//给myp赋值相当于给主函数中的pT1赋值 myp = (Teacher*)malloc(sizeof(Teacher)); if (myp == NULL) { return -1; } p->age = 36; } void FreeTeacher(Teacher *pT1) { if (pT1 == NULL) { return; } free(pT1); } void main() { Teacher *pT1 = NULL; getTeacher(&pT1);//二级指针 cout << ＂age:＂ << pT1->age << endl; FreeTeacher(pT1); getTeacher2(pT1);//引用 cout << ＂age:＂ << pT1->age << endl; FreeTeacher(pT1); cout << ＂hello..＂ << endl; system(＂pause＂); return; }
c++中的const常量
可能分配内存空间,也可能不分配
当const常量为全局,并且需要在其他文件中使用,会分配空间
在使用&操作符,取const常量的地址,会分配
当const修饰引用,会分配#include using namespace std; void main() { int x = 20; const int &y = x;//常引用 让变量拥有只读属性 不同通过y去修改x了 //常引用初始化分为2种情况//1)用变量 初始化 常引用 { int x1 = 30; const int &y1 = x1; } //2)用字面量 初始化 常引用 { const int a = 40; int &m = 41;//普通引用 引用一个字面量 //字面量有没有内存地址?-->没有 } cout << ＂hello..＂ << endl; system(＂pause＂); return; }
结论:
const &int e==const int* const e
普通引用==int const e
当使用常量对const引用进行初始化时,编译器会为常量值分配空间,并用引用名作为这段空间的别名
使用字面量对const引用初始化后,将生成一个只读变量