浅学指针(2)数组函数传值调用

系列文章目录

文章目录

  • 系列文章目录
  • 前言
  • 1. 指针的使⽤和传址调⽤
    • 结论:实参传递给形参的时候,形参会单独创建⼀份临时空间来接收实参,对形参的修改不影响实 参。
    • 那么这个时候,就要搬出指针大哥,在main函数中将a和b的地址传递给Swap函数,Swap函数⾥边通过地址间接的操作main函数中的a和b,像是把家(地址)搬到函数中,直接改变家里的东西(a, b的值)。
  • 2 .数组名的理解
    • 所以说:数组名就是数组⾸元素(第⼀个元素)的地址。
  • 3. 使⽤指针访问数组
  • 4 . 一维数组函数传参形本质
    • 接下来进入重点,⾸先从⼀个问题开始,我们之前都是在函数外部计算数组的元素个数,那我们可以把函数传给⼀个函数后,函数内部求数组的元素个数吗?
  • 5. ⼆级指针
    • 总结:2级指针是存放一级指针的地址
  • 6. 指针数组
    • 指针数组是存放指针的数组
    • 但是并非是2维数组,原因是模拟的数组并不连续,而数组在内存上是连续存放的。


前言

1. 指针的使⽤和传址调⽤

学习指针的⽬的是使⽤指针解决问题,那什么问题,⾮指针不可呢?

案例:写⼀个函数,交换两个整型变量的值
代码如下:

#include 
void Swap1(int x, int y)
{
 	int tmp = x;
 	x = y;
 	y = tmp;
}
int main()
{
 	int a = 0;
 	int b = 0;
 	scanf("%d %d", &a, &b);
 	printf("交换前:a=%d b=%d\n", a, b);
 	Swap1(a, b);
 	printf("交换后:a=%d b=%d\n", a, b);
 return 0;
}

输出结果:
浅学指针(2)数组函数传值调用_第1张图片
这是为什么呢?
浅学指针(2)数组函数传值调用_第2张图片

我们发现在main函数内部,创建了a和b,a的地址是0x00cffdd0,b的地址是0x00cffdc4,在调⽤Swap1函数时,将a和b传递给了Swap1函数,在Swap1函数内部创建了形参x和y接收a和b的值,但是x的地址是0x00cffcec,y的地址是0x00cffcf0,x和y确实接收到了a和b的值,不过x的地址和a的地址不⼀样,y的地址和b的地址不⼀样,相当于x和y是独⽴的空间,那么在Swap1函数内部交换x和y的值,⾃然不会影响a和b,当Swap1函数调⽤结束后回到main函数,a和b的没法交换。Swap1函数在使⽤的时候,是把变量本⾝直接传递给了函数,这种调⽤函数的⽅式我们之前在函数的时候就知道了,这种叫传值调⽤。

结论:实参传递给形参的时候,形参会单独创建⼀份临时空间来接收实参,对形参的修改不影响实
参。

所以Swap是失败的了。

那么这个时候,就要搬出指针大哥,在main函数中将a和b的地址传递给Swap函数,Swap函数⾥边通过地址间接的操作main函数中的a和b,像是把家(地址)搬到函数中,直接改变家里的东西(a, b的值)。

代码展示:

#include
void Swap2(int*px, int*py)
{
 	int tmp = 0;
 	tmp = *px;
 	*px = *py;
 	*py = tmp;
}
int main()
{
 	int a = 0;
 	int b = 0;
 	scanf("%d %d", &a, &b);
 	printf("交换前:a=%d b=%d\n", a, b);
 	Swap1(&a, &b);
 	printf("交换后:a=%d b=%d\n", a, b);
 return 0;
}

输出结果:
浅学指针(2)数组函数传值调用_第3张图片
我们可以看到实现成Swap2的⽅式,顺利完成了任务,这⾥调⽤Swap2函数的时候是将变量的地址传递给了函数,这种函数调⽤⽅式叫:传址调⽤。

2 .数组名的理解

如下代码:

#include 
int main()
{
 	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
 	printf("&arr[0] = %p\n", &arr[0]);
 	printf("arr = %p\n", arr);
 	return 0;
}

输出结果:
浅学指针(2)数组函数传值调用_第4张图片

所以说:数组名就是数组⾸元素(第⼀个元素)的地址。

但是有两个例外:

• sizeof(数组名),sizeof中单独放数组名,这⾥的数组名表⽰整个数组,计算的是整个数组的⼤⼩,
单位是字节
• &数组名,这⾥的数组名表⽰整个数组,取出的是整个数组的地址(整个数组的地址和数组⾸元素
的地址是有区别的)
除此之外,任何地⽅使⽤数组名,数组名都表⽰⾸元素的地址。

还有一点,arr和&arr有啥区别:

#include 
int main()
{
 	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
 	printf("&arr[0] = %p\n", &arr[0]);
 	printf("&arr[0]+1 = %p\n", &arr[0]+1);
 	printf("arr = %p\n", arr);
 	printf("arr+1 = %p\n", arr+1);
 	printf("&arr = %p\n", &arr);
 	printf("&arr+1 = %p\n", &arr+1);
 return 0;
}

输出结果:
浅学指针(2)数组函数传值调用_第5张图片
这⾥我们发现&arr[0]和&arr[0]+1相差4个字节,arr和arr+1 相差4个字节,是因为&arr[0] 和 arr 都是⾸元素的地址,+1就是跳过⼀个元素。
但是&arr 和 &arr+1相差40个字节,这就是因为&arr是数组的地址+1 操作是跳过整个数组的。到这⾥⼤家应该搞清楚数组名的意义了吧。

3. 使⽤指针访问数组

有了前面知识,我们便可以使用指针访问数组啦!其实数组也相当于指针,如:*(p + 1)= arr[1],扩展
浅学指针(2)数组函数传值调用_第6张图片
数组名arr是数组⾸元素的地址,可以赋值给p,其实数组名arr和p在这⾥是等价的。那我们可以使⽤arr[i]可以访问数组的元素,那p[i]是否也可以访问数组呢?`

#include 
int main()
{
 	int arr[10] = {0};
 	//输⼊
 	int i = 0;
 	int sz = sizeof(arr)/sizeof(arr[0]);
 	//输⼊
 	int* p = arr;
 	for(i=0; i<sz; i++){
 		scanf("%d", p+i);
 		//scanf("%d", arr+i);//也可以这样写
 	}
 	//输出
 	for(i=0; i<sz; i++){
 		printf("%d ", p[i]);
 	}
 return 0;
}

在第18⾏的地⽅,将*(p+i)换成p[i]也是能够正常打印的,所以本质上p[i] 是等价于 *(p+i)。

4 . 一维数组函数传参形本质

接下来进入重点,⾸先从⼀个问题开始,我们之前都是在函数外部计算数组的元素个数,那我们可以把函数传给⼀个函数后,函数内部求数组的元素个数吗?

展示如下:

#include 
void test(int arr[])
{
 	int sz2 = sizeof(arr)/sizeof(arr[0]);
	 printf("sz2 = %d\n", sz2);
}
int main()
{
 	int arr[10] = {1,2,3,4,5,6,7,8,9,10};
 	int sz1 = sizeof(arr)/sizeof(arr[0]);
 	printf("sz1 = %d\n", sz1);
 	test(arr);
 return 0;
}

输出结果:
浅学指针(2)数组函数传值调用_第7张图片

很明显函数是没有正确获得数组元素个数的,上面我们学习了数组名是数组⾸元素的地址;那么在数组传的时候,传递的是数组名,也就是说本质上数组传参本质上传递的是数组⾸元素的地址。
所以函数形参的部分理论上应该使⽤指针变量来接收⾸元素的地址。

那么在函数内部我们写sizeof(arr) 计算的是⼀个地址的⼤⼩(单位字节)⽽不是数组的⼤⼩(单位字节)。正是因为函数的参数部分是本质是指针,所以在函数内部是没办法求的数组元素个数的。

总结:⼀维数组传参,形参的部分可以写成数组的形式,也可以写成指针的形式.

5. ⼆级指针

浅学指针(2)数组函数传值调用_第8张图片
要理解如下:

int main()
{
	int a = 30;
	int * pa = &a;//取出a的地址 * 表示pa是指针,指针的类型是int类型
	int * * ppa = &p;//ppa前的*表示ppa是指针,指针的类型是int *类型
}

2级指针的解引用
对上面案例分析,像是扒白菜一样,一层一层来,如下展示:
浅学指针(2)数组函数传值调用_第9张图片

最终得到结果

总结:2级指针是存放一级指针的地址

6. 指针数组

指针数组是存放指针的数组

浅学指针(2)数组函数传值调用_第10张图片
浅学指针(2)数组函数传值调用_第11张图片
结合如上知识,那么指针是可以模拟数组的
扩展:指针数组模拟⼆维数组

#include 
int main()
{
 	int arr1[] = {1,2,3,4,5};
 	int arr2[] = {2,3,4,5,6};
 	int arr3[] = {3,4,5,6,7};
 	//数组名是数组⾸元素的地址,类型是int*的,就可以存放在parr数组中
 	int* parr[3] = {arr1, arr2, arr3};
 	int i = 0;
 	int j = 0;
 	for(i=0; i<3; i++){
 		for(j=0; j<5; j++){
 			printf("%d ", parr[i][j]);
 		}
 		printf("\n");
 	}
  return 0;
}

图来展示:
浅学指针(2)数组函数传值调用_第12张图片

parr[i]是访问parr数组的元素,parr[i]找到的数组元素指向了整型⼀维数组,parr[i][j]就是整型⼀维数组中的元素。

但是并非是2维数组,原因是模拟的数组并不连续,而数组在内存上是连续存放的。

都看到这里了,那就点个赞吧,学习大家

你可能感兴趣的:(C语言,学习,c语言,算法)