1 引用概念 引用概念
1)在C++中新增加了引用的概念
2)引用可以看作一个已定义变量的别名
3)引用的语法:Type& name = var;
4)引用做函数参数那?(引用作为函数参数声明时不进行初始化)
实例:
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int a = 666;
float c = 10.0;
int &b = a;
float &d = c;
//不能直接定义没有指向的别名
int &e = a;
printf("a = %d, b: %d\n", a, b);
b = 888;
printf("a = %d, b: %d\n", a, b);
printf("a 的地址:%p, b 的地址:%p\n", &a, &b);
system("pause");
return 0;
}
2 引用是 C++的概念 的概念
属于C++编译器对C的扩展。
实例:
//问题:C中可以编译通过吗?
int main()
{
int a = 0;
int &b = a;
b = 11; //*b = 11;
return 0;
}
//结论:请不要用C的语法考虑 b=11
3 引用做函数参数 引用做函数参数
普通引用在声明时必须用其它的变量进行初始化,引用作为函数参数声明时不进行初始化。
实例:
#include <stdio.h>
#include <stdlib.h>
void swap(int a, int b) {
int tmp = a;
a = b;
b = tmp;
}
//方式一,使用指针
void swaq1(int *a, int *b) {
int tmp = *a;
*a = *b;
*b = tmp;
}
//方式二,使用引用
void swaq2(int &a, int &b) {
//int &c; //不可以
int tmp = a;
a = b;
b = tmp;
}
int main(void) {
int x = 10, y = 100;
//swaq1(&x, &y);
swaq2(x, y);
printf("x: %d, y: %d\n", x, y);
system("pause");
return 0;
}
4 引用的意义
1)引用作为其它变量的别名而存在,因此在一些场合可以代替指针。
2)引用相对于指针来说具有更好的可读性和实用性。
实例:
#include <stdio.h>
#include <stdlib.h>
int swap(int &a, int &b){
int t = a;
a = b;
b = t;
return 0;
}
int swap(int *a, int *b){
int t = *a;
*a = *b;
*b = t;
return 0;
}
5 引用本质思考
思考1:C++编译器背后做了什么工作?
实例:
#include <stdio.h>
#include <stdlib.h>
/*int swap1(int &a, int &b) {
int t = a;
a = b;
b = t;
return 0;
}*/
int swap2(int * const _a, int *const _b) {
int t = *_a;
*_a = *_b;
*_b = t;
return 0;
}
int main(void) {
int x = 10;
int &y = x;
int z = 1000;
int w = 10000;
y = z; //y是没有办法指向z
printf("x: %d y: %d z: %d w: %d \n", &x, &y, &z, &w);
//int &b = a;
//b是a的别名,请问C++编译器后面做了什么工作?
//1. 请思考:对同一内存空间可以取好几个名字吗?
//int &c = a;
//int &d = a;
//printf("a: %d b: %d c: %d d: %d\n", a, b, c, d);
//2. 引用有没有自己的空间
//结论:引用可以定义多个,引用有自己的空间,那么,引用像什么?
//综上几点分析:别名很想常指针
//int &b = a; int * const b = &a;
//swaq1(z, w); 换成 swaq2(&z, &w);
swap2(&z, &w);
printf("z: %d, w: %d \n", z, w);
system("pause");
return 0;
}
6 引用的本质 引用的本质
1)引用在C++中的内部实现是一个常指针
Type& name <-- -->Type* const name
2)C++编译器在编译过程中使用常指针作为引用的内部实现,因此引用所占用的空间大小与指针相同。
3)从使用的角度,引用会让人误会其只是一个别名,没有自己的存储空间。这是C++为了实用性而做出的细节隐藏。
实例:
#include <stdio.h>
#include <stdlib.h>
void func(int &var){
var = 15;
}
void func(int *const var){
*var = 15;
}
int main(void){
int value= 10;
func(value);
system("pause");
return 0;
}
7 引用结论 引用结论
1)当实参传给形参引用的时候,只不过是c++编译器帮我们程序员手工取了一个实参地址,传给了形参引用(常量指针)。
2)当我们 使用引用语法的时,我们不去关心编译器引用是怎么做的当我们 分析奇怪的语法现象的时,我们才去考虑c++编译器是怎么做的。
8 指针引用
实例:
#include <stdio.h>
#include <stdlib.h>
void boy_home(int **meipo) {
static int boy = 23;
*meipo = &boy;
}
void boy_home1(int* &meipo) {
static int boy = 23;
meipo = &boy;
}
int main(void) {
/*int x = 666;
int *p = &x;
int* &q = p; //定义指针变量的引用
printf("*p: %d *q: %d\n", *p, *q);*/
int *meipo = NULL;
//boy_home(&meipo);
boy_home1(meipo);
printf("boy: %d\n", *meipo);
system("pause");
return 0;
}
9 常引用 常引用
在 C++中可以声明 const 引用
语法: const Type& name = var;
const 引用让变量拥有只读属性
分两种情况:
- 用变量初始化常引用
- 用字面量初始化常量引用
实例:
#include <stdio.h>
#include <stdlib.h>
int main(void) {
int a = 10;
//int &b =a;
//1. 用变量初始化常引用。
const int &b = a;
//b = 100; //常引用是让变量引用变成只读,不能通过引用对变量进行修改。
printf("a: %d\n", a);
//2. 用字面量初始化常量引用。
const int c1 = 10;
const int &c2 = 10;//这个是在C++中,编译器会对这样的定义的引用分配内存,这算是一个特例。
int c3 = c2;
//c2 = 100;
system("pause");
return 0;
}
const 引用结论:
1)const & int e 相当于 const int * const e
2)普通引用 相当于 int *const e1
3)当使用常量(字面量)对const引用进行初始化时,C++编译器会为常量值分配空间,并将引用名作为这段空间的别名。
4)使用字面量对const引用初始化后,将生成一个只读变量
这是我第一次写博客效果可能不是很好,但是我以后会加油的。
以上是上课时做的笔记,我个人认为写的还不错所以才发布的。