【C语言指针超详解(三)】--数组名的理解，一维数组传参的本质，冒泡排序，二级指针，指针数组

目录

一.数组名的理解

二.使用指针访问数组

三.一维数组传参的本质 

四.冒泡排序

五.二级指针 

六.指针数组

6.1--指针数组的定义

6.2--指针数组模拟二维数组

---

🔥个人主页：@草莓熊Lotso的个人主页

🎬作者简介：C++方向学习者

📖个人专栏：《C语言》

---

一.数组名的理解

--在前面的学习中，我们使用指针访问数组时一般会采用以下两种形式，它们所到达的效果也是相同的。

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

在上述代码中我们分别使用&arr[0]和arr的方式拿到了数组的第一个元素的地址，这是因为数组名本身就是地址，而且是数组首元素的地址。

但是有两个例外我们需要注意一下:

• sizeof(数组名)，sizeof中单独放数组名，这⾥的数组名表示整个数组，计算的是整个数组的⼤小，单位是字节
• &数组名，这里的数组名表示整个数组，取出的是 整个数组的地址(整个数组的地址和数组首元素的地址是有区别的)

那么我们就通过两个例子具体分析一下吧~

例子1:

#include <stdio.h>
int main()
{int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };printf("%d\n", sizeof(arr));return 0;
}

如果arr是数组首元素的地址，那输出的应该是4/8 ，但这串代码的输出结果最后是40，这就证明的sizeof(数组名)计算的是整个数组的大小。

例子2：

#include <stdio.h>
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;
}

我们来分步解析一下这串代码:

1. 我们可以发现光看&arr，arr，&arr[0]打印出来的地址并没有任何区别，这是因为数组的起始地址也是首元素的地址，所以我们接下来对它们分别＋1 来找区别。
2. ＋1之后我们会发现，&arr[0]和&arr[0]+1相差4个字节，arr和arr+1 相差4个字节，但是&arr 和 &arr+1相差40个字节。
3. 这是因为&arr[0] 和 arr 都是⾸元素的地址，+1就是跳过⼀个元素，但是&arr是数组的地址，+1 操作是跳过整个数组的。

到这里想必大家都对数组名的意义有了正确的理解，我们接着往下看吧。

---

二.使用指针访问数组

--学习了前面的知识后，再结合数组的特点，我们就可以更方便的使用指针访问数组了。

#include <stdio.h>
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));//*(p+i)等价于*(arr+i)也可写成arr[i]}return 0;
}

 通过上述代码我们可知，在这里arr和p是等价的，那我们可以使用arr[i]访问数组，是不是也可以使用p[i]呢？

答案是当然可以，其实本质上p[i]是等价于*(p+i)的，那么同理arr[i] 应该等价于 *(arr+i)，数组元素的访问在编译器处理的时候，也是转换成⾸元素的地址+偏移量求出元素的地址，然后解引⽤来访问的，所以这几个使用那个都可以正确的打印出来结果。

还有一个比较有意思的等价关系给大家分享一下，但是不推荐使用:

arr[i] == *(arr+i) == *(i+arr) == i[arr]

大家可以发现，后面两个等价的很怪，但确实是可行的，其实就是用了交换律而已。

---

三.一维数组传参的本质 

--数组我们学过了，之前也讲了，数组是可以传递给函数的，这个小节我们讨论⼀下数组传参的本质。

首先从⼀个问题开始，我们之前都是在函数外部计算数组的元素个数，那我们可以把数组传给⼀个函数后，函数内部求数组的元素个数吗？

#include <stdio.h>
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;
}

我们通过上面这串代码的输出结果可以看出在函数内部没有正确获得数组的元素个数。这就涉及到数组传参的本质了。

之前我们学习了：数组名是数组首元素的地址；那么在数组传参的时候，传递的是数组名，也就是说本质上数组传参传递的是数组首元素的地址。

        -- 所以函数形参的部分理论上应该使⽤指针变量来接收首元素的地址。那么在函数内部我们写sizeof(arr)计算的是⼀个地址的大小（单位字节），也就是计算一个指针变量的大小，而不是数组的大小（单位字节）。正是因为函数的参数部分的本质是指针，所以在函数内部是没办法求数组元素个数的。

void test(int arr[])//参数写成数组形式，本质上还是指针
{printf("%d\n", sizeof(arr));
}
void test(int* arr)//参数写成指针形式
{printf("%d\n", sizeof(arr));//计算⼀个指针变量的⼤⼩
}
int main()
{int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };test(arr);return 0;
}

 总结:一维数组传参，形参的部分可以写成数组的形式，也可以写成指针的形式。

---

四.冒泡排序

--冒泡排序的核心思想:两两相邻的元素进行比较。

//方法一
#include<stdio.h>
#include<string.h>void bubble_sort(int arr[], int sz)
{int i = 0;//趟数=元素个数-1=sz-1;for (i = 0;i < sz - 1;i++){int j = 0;//每一趟要比较的次数=元素个数-当前趟数-1=sz-i-1;for (j = 0;j < sz - i - 1;j++){if (arr[j] > arr[j + 1]){int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}
}
void print_arr(int arr[], int sz)
{for (int i = 0;i < sz;i++){printf("%d ", arr[i]);}
}
int main()
{int arr[10] = { 0 };//如果是arr[]，后面就无法自己输入数字，要注意int sz = sizeof(arr) / sizeof(arr[0]);printf("请输入待排序的数字: ");for (int n = 0;n < sz;n++){scanf("%d", arr + n);}bubble_sort(arr, sz);printf("排序完成后的数字是: ");print_arr(arr, sz);return 0;
}

//方法二--优化
#include<stdio.h>
#include<string.h>
void bubble_sort(int arr[], int sz)
{int i = 0;//趟数=元素个数-1=sz-1;for (i = 0;i < sz - 1;i++){int j = 0;int flag = 0;//假设这趟是有序的//每一趟要比较的次数=元素个数-当前趟数-1=sz-i-1;for (j = 0;j < sz - i - 1;j++){if (arr[j] > arr[j + 1]){int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;flag = 0;//只要这趟有一次发生交换的，则无序}}if (flag == 1);//这一趟一次交换都没发生就说明已经有序了，不用继续排序了break;}
}
void print_arr(int arr[], int sz)
{for (int i = 0;i < sz;i++){printf("%d ", arr[i]);}
}
int main()
{int arr[10] = { 0 };//如果是arr[]，后面就无法自己输入数字，要注意int sz = sizeof(arr) / sizeof(arr[0]);printf("请输入待排序的数字: ");for (int n = 0;n < sz;n++){scanf("%d", arr + n);}bubble_sort(arr, sz);printf("排序完成后的数字是: ");print_arr(arr, sz);return 0;
}

优化后的方法可以减少比较的次数，大大减少了程序运行的时间。

---

五.二级指针 

 --指针变量也是变量，是变量就有地址，那指针变量的地址存放在哪里呢。

那就是存放在二级指针里。

对于二级指针的运算有：

• *ppa 通过对ppa中的地址进⾏解引⽤，这样找到的是 pa ，*ppa 其实访问的就是 pa 。

1  int b = 20;

2  *ppa = &b;//等价于 pa = &b;

• **ppa 先通过 *ppa 找到 pa ,然后对 pa 进⾏解引⽤操作：*pa ，那找到的是 a 

1 **ppa = 30;

2 //等价于*pa = 30;

3 //等价于a = 30; 

---

六.指针数组

6.1--指针数组的定义

--我们先来思考一下指针数组是指针还是数组呢?

我们类比⼀下，整型数组，是存放整型的数组，字符数组是存放字符的数组。

那指针数组呢？那肯定就是存放指针的数组。

 指针数组的每个元素都是用来存放地址(指针)的。指针数组的每个元素都是地址，又可以指向一块区域。

6.2--指针数组模拟二维数组

#include <stdio.h>
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;
}

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

上述的代码可以模拟出二维数组的效果，实际上并非完全是二维数组，因为每一行并非是连续的。

---

往期回顾：

【C语言】--指针超详解(一)

【C语言】--指针超详解(二)

 结语:本篇文章就到此结束了，继前面两篇文章后在此篇文章中给大家分享了大量数组和指针之间相联系的知识点，还有冒泡排序等，如果文章对你有帮助的话，欢迎评论，点赞，收藏加关注，感谢大家的支持，后续会继续更新指针相关内容。