C/C++指针类型与引用类型的基本使用_引用类型 指针类型

指针类型使用

指针数据类型，自己本身保存的是其他变量的地址，通过指针数据类型可以操作其保存的地址的那个变量的值;

int a = 10;
int b = 20;
int * p = &a;//p指针保存了a的地址
p = &b;//将变量b的地址重新赋值给p指针
*p = 50;//修改指针p保存的那个变量地址的值，也就是将变量b的值修改为50
printf("*p = %d\n",*p);//50
printf("b = %d\n",b);//50
1
2
3
4
5
6
7

在函数调用时，不管是基本数据类型还是结构体等类型，都会在内存中重新创建一个变量，也就是说，在调用的函数里面修改了变量的值不会影响调用者的函数。

void update(int a){
	a = 20;
}

int main(){
	int a = 10;
	update(a);
	printf("a = %d\n",a);//10
	return -1;
}
1
2
3
4
5
6
7
8
9
10

但是如果是使用的指针类型，则在调用函数时不会创建新变量，对指针或指针变量的修改会影响调用者函数的变量

void update(int *a){
	*a = 20;
}

int main(){
	int a = 10;
	update(&a);//传入a的地址
	printf("a = %d\n",a);//20
	return -1;
}
1
2
3
4
5
6
7
8
9
10

结构体数据类型指针传递 ，如果是结构体指针类型，则还是一样的效果修改指针，会修改对应的值，也会影响到调用者的指针变量的值，但是结构体类型指针在取值和赋值时要用 ->.

typedef struct Student{
	int age;
	int score;
} stu ;


void updateStu(stu s){
	s.age = 100;
	s.score = 200;
};

int main(){

	stu s;
	s.age = 10;
	s.score = 20;
	updateStu(s);
	printf("s.age = %d\n",s.age);
	printf("s.socre = %d\n",s.score);
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

以上代码无法修改main函数中结构体s的值，要想在函数中修改main函数s的值，需要使用指针，同时结构体类型用指针时，注意 -> 的使用。

typedef struct Student{
	int age;
	int score;
} stu ;


void updateStu(stu *s){
	s -> age = 100;
	s -> score = 200;
};

int main(){

	stu s;
	s.age = 10;
	s.score = 20;
	updateStu(&s);
	printf("s.age = %d\n",s.age);
	printf("s.socre = %d\n",s.score);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

指针类型如果在函数中重新赋值，此时在mian函数中是无效的。

void update(int *a){
	int b = 555;
	a = &b;
}

int main(){
	int a = 10;
	int *p = &a;
	update(p);
	printf("*p = %d\n",*p);// 还是等于10
	return -1;
}
1
2
3
4
5
6
7
8
9
10
11
12

引用类型使用

引用数据类型针对于指针数据类型更加强大，在调用函数时，不需要加 &传入变量地址，替代了（地址就是指针，指针就是地址）指针，只需要传入变量，然后形参位置 在数据类型后面 加 &符号就表示是一个xxx类型的引用 ，如 int &，表示一个int类型的引用，int * &表示一个int *类型的引用，直接在函数中修改引用的值，也是可以修改原变量的。

基本使用

void updateInt(int & num){
	num = 50;
}

int main(){
	
	int a = 10;
	updateInt(a);
	printf("a = %d \n",a);
	
	return -1;
}
1
2
3
4
5
6
7
8
9
10
11
12

引用类型数据修改了值以后，main函数会同步修改

#include <stdio.h> 

typedef struct Student{
	int age;
} stu ;

void updateStu(stu & s){
	s.age = 20;
} 

int main(){
	
	stu s;
	s.age = 10;
	updateStu(s);
	printf(" s.age = %d\n",s.age);

	return -1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

如果是直接重新赋值结构体也是可以的

#include <stdio.h> 

typedef struct Student{
	int age;
} stu ;

void updateStu(stu &s){
	stu ss;
	ss.age = 888;
	s = ss;
} 

int main(){
	
	stu s;
	s.age = 10;
	updateStu(s);
	printf(" s.age = %d\n",s.age);

	return -1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

• 结构体类型对于指针的应用

基本数据类型的指针，还是和上面的一样用，如果是指针重新赋值 *x = xxx;则还是和原来一样的效果，但是如果是指针直接赋值，也会重新修改main函数里的指针变量

void updateData(int * & p){
	int b = 20;
	p = &b;
}

int main(){
	
	int a = 10;
	int *p = &a;
	updateData(p);
	printf(" *p = %d\n",*p);// *p = 20;
	return -1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

结构体指针引用类型的使用

void updateStu(stu * &s){
	stu ss;
	ss.age = 888;
	s = &ss;
} 

int main(){

	stu s;
	s.age = 10;
	stu * sp;
	sp = &s;
	updateStu(sp);
	printf(" sp -> age =  %d\n",sp -> age);// 888
	return -1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

指针类型对比引用类型

• 调用函数函数时，如果想修改一个形参的值也影响主函数中的值，则用指针或引用都可以，但是用指针只能通过 *p 来给指针保存的地址对应的变量赋值，如果给指针变量重新赋值了，则还是不影响到main函数中的变量值。

• 引用类型可以当作普通类型使用，只不过引用类型的赋值会影响到main函数中变量的值，因为在传递参数时，只是把这个引用（地址给传了过去），c++并不会再次创建新变量赋值，而是直接修改的引用地址的值。