在上一篇深入理解指针(1)中我们已经初步了解指针地址；指针的解引用；指针变量类型作用，指针运算等知识，接下来我们将继续学习指针的相关内容，一起加油吧！！！
1. 数组名的理解
在之前的学习中我们知道可以将一串数字存放在整形指针当中，而且指针在内存当中存放是连续的，就可以通过取地址的方式找到数组当中想要的元素
int arr[]={1,2,3,4,5,6,7,8,9}:
int*pa=&arr[0];
在之前还提到过在函数实参中数组名表示首元素的地址，那在指针中这样规律是否还适用呢？
#include<stdio.h> int main() { int arr[] = { 1,2,3,4,5,6,7,8,9 }; printf("&arr[0]=%p\n", &arr[0]); printf("arr=%p ", arr); return 0; }
通过以上代码发现&arr[0]与arr的地址是相同的，因此可以得出数组就是首元素的地址
那数组就是首元素的地址是在所有条件下都成立吗？
1.在sizeof(数组名)中
#include<stdio.h> int main() { int arr[] = { 1,2,3,4,5,6,7,8,9 }; printf("sizeof(arr)=%zd\n", sizeof(arr)); printf("sizeof(arr[0])=%zd\n", sizeof(arr[0])); return 0; }
如果在sizeof() 内arr表示首元素的地址，那么在x86环境下，应该sizeof(arr)的大小与sizeof(arr[0])一样为4字节，但在以上运行结果可以看出sizeof(arr)的大小为36字节，说明arr在sizeof内表示的不是首元素而是整个数组，计算的是整个数组的大小
1.在&数组名中
#include<stdio.h>
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9 };
printf("arr =%p\n", arr );
printf("&arr[0] = %p\n", &arr[0] );
printf("&arr =%p\n", &arr );
printf("arr + 1 =%p\n", arr + 1);
printf("&arr[0] + 1=%p\n", &arr[0] + 1);
printf("&arr + 1 =%p\n", &arr + 1);
return 0;
}
在x86环境下，由于地址是以16进制表示的，以上代码运行结果可以看出arr+1和&arr[0]+1都让地址先后移动4个字节，而&arr+1是让地址向后移动了36个字节，由于在整形数组arr中有9个元素，说明&arr+1是向后移动了一个数组大小的步长，因此可见在&arr不是取出数组首元素地址而是取出整个数组的地址
通过以上的例子现在就知道其实数组名就是数组首元素(第⼀个元素的地址），但是有两个例外：
• sizeof(数组名)，sizeof中单独放数组名，这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节。
• &数组名，这里的数组名表示整个数组，取出的是整个数组的地址（整个数组的地址和数组首素
的地址是有区别的）
除此之外，任何地方使用数组名，数组名都表示首元素的地址
2. 使用指针访问数组
在之前学习完数组后我们知道可以用数组下标的方式来访问数组，例如以下代码
#include<stdio.h> int main() { int arr[9] = { 0 }; int sz = sizeof(arr) / sizeof(arr[0]); for (int i = 0; i < sz; i++) { scanf("%d", &arr[i]); } for (int i = 0; i < sz; i++) { printf("%d ", arr[i]); } return 0; }
其实还可以用指针的方式访问数组
#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> int main() { int arr[9] = { 0 }; int sz = sizeof(arr) / sizeof(arr[0]); int* p = arr; for (int i = 0; i < sz; i++) { scanf("%d",p+i); } for (int i = 0; i < sz; i++) { printf("%d ", *(p+i)); } return 0; }
因为数组名表示首元素的地址，对以上代码的arr+i就是arr跳过i个元素，所以在以上代码中将scanf("%d",p+i);替换成为scanf("%d",arr+i);也是可行的
将*(p+i)换成p[i]也是能够正常打印的，所以本质上p[i] 是等价于 *(p+i)
同理arr[i] 应该等价于 *(arr+i)
因为加法是支持交换律的所以*(arr+i)等价*(i+arr)
结论：*(arr+i)=arr[i]=*(i+arr)=i[arr]
由此看见[ ]其实是一个操作符
其实数组元素的访问在编译器处理的时候，也是转换成首元素的地址+偏移量求出元素的地址，然后解引用来访问的
3. 一维数组传参的本质
#include <stdio.h> void test(int arr[10]) { 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； }
在以上代码中为什么在函数test内的sz2输出的值为1呢？
首先通过以上学习知道数组名表示首元素的地址，所以在test()实参中的arr传给形参的是首元素的地址，所以在test函数内的sizeof(arr)计算出的是地址大小，又因为是在x86环境下，计算结果是4字节
在数组传参时，形参接收的其实是地址 ，所以应该用指针去接收，写成为int* arr的形式，因此我们上面代码形参写的int arr[10]其实不是数组而是指针，之前写成数组的形式只是为了让我们更好理解
之前在指针传参时候说过形参的数组元素个数可以省略不写，现在我们知道了因为形参接收的是地址，不需要接收数组大小，所以可以省略不写
总结：⼀维数组传参，形参的部分可以写成数组的形式，也可以写成指针的形式。
通过以上的了解在计算数组元素个数时，要在数组所在的函数内就求出，不要通过传参的方式在另一个函数内计算
4. 冒泡排序
当有一是乱序的数字时候，要编写一个程序使得输出的数字大小由大到小，我们应该怎么实现呢
在这里使用到的是冒泡排序，冒泡排序的核心思想就是：两两相邻的元素进行比较，不满足顺序就交换，满足就找下一对
1.冒泡排序趟数分析
当输入为9 8 7 6 5 4 3 2 1 0 在冒泡排序中是有多套的，例如以下就是一套冒泡排序
一套进行完就会将最大的数排到最后，此时就要进行下一套排序
最终进行完9趟后就使数由小到大排序了
因此从以上例子发现当输入值个数为n个时候，只需n-1趟排序就可以实现升序效果
2.冒泡排序每一趟内部比较分析
例如在的数字串中，第一趟排序中需要进行9对数字的比较，在第二趟排序中需要进行8对数字的比较，所以当趟数为i时候；当在第n趟排序中需要进行n-1-i对数字的比较
3.代码实现
void bubble_sort(int* arr, int sz) { for (int i = 0; i < sz - 1; i++)//每排序都会确定一个数的位置 { for (int j = 0; j < sz - 1 - i; j++)// { if (arr[j] > arr[j + 1]) { int tmp = arr[j]; arr[j ] = arr[j+1]; arr[j + 1] = tmp; } } } } int main() { int arr[10] = { 0 }; int sz = sizeof(arr) / sizeof(arr[0]); for (int i = 0; i < sz; i++) { scanf("%d", &arr[i]); } bubble_sort(arr, sz); for (int i = 0; i < sz; i++) { printf("%d ", arr[i]); } return 0; }测试程序运行
4.代码优化
在以上冒泡排序程序确实可以实现升序排列，但如果当输入数字串一开始就是生序的时，当走完一趟一对数都没有进行交换，但还是会进行n-1趟排序，这就会使程序在运行时浪费很多时间，因此我们有什么优化的方法呢？
void bubble_sort(int* arr, int sz)
{
for (int i = 0; i < sz - 1; i++)//每排序都会确定一个数的位置
{
int flag=1;//假设这一趟已经有序
for (int j = 0; j < sz - 1 - i; j++)//
{
if (arr[j] > arr[j + 1])
{
int flag=0;//这一趟无序
int tmp = arr[j];
arr[j ] = arr[j+1];
arr[j + 1] = tmp;
}
}
if(flag==1)//这⼀趟没交换就说明已经有序，后续⽆序排序了
break;
}
}
int main()
{
int arr[10] = { 0 };
int sz = sizeof(arr) / sizeof(arr[0]);
for (int i = 0; i < sz; i++)
{
scanf("%d", &arr[i]);
}
bubble_sort(arr, sz);
for (int i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
return 0;
}5. 二级指针
之前我们学习的指针都是一级指针，现在将继续学习二级指针相关知识点
那么二级指针是什么呢？
二级指针就是存放指针变量地址的指针
int main()
{
int a = 10;
int* p = &a; //p是一级指针变量
int** pp = &p;//pp就是二级指针变量
return 0;
}在int ** pp中第二个*表示pp是指针变量，第一个*表示pp指向的p类型是int *
通过调试可以了解这几个变量之间的关系
int main() { int a = 10; int* p = &a; //p是一级指针变量 int** pp = &p;//pp就是二级指针变量 printf("a=%d", **pp); return 0; }
因为**pp=*p=a，当打印**pp时，就是a的地址找出变量a
6. 指针数组
1.指针数组概念
在之前我们学习了整形数组就是存放整形的数组，数组的每个元素是整形类型；字符数组就是存放字符的数组，数组的每个元素是字符类型
因此就可以类比出指针数组就是存放指针的数组，数组的每个元素是指针类型
例如在整形数组中,数组元素个数为5，若数组名为arr 则可表示为int arr[5]
因此但这个是指针数组时，就可以类别出该数组可表示为int* arr[5],这里的int*表示数组的元素类型为int*
int main()
{
int a = 10;
int b = 20;
int c = 30;
int* pa = &a;
int* pb = &b;
int* pc = &c;
return 0;
}但我们要创建多个相同类型的指针变量时，使用以上方法就会让代码臃肿，还有说明更好的方法呢？
因为a b c三个变量都是整形类型，这时就可以用到指针数组int main() { int a = 10; int b = 20; int c = 30; int* parr[3] = { &a,&b,&c }; return 0; }
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[3] = {arr1,arr2,arr3};
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 5; j++)
{
printf("%d ", *(*(parr + i) + j));
}
printf("\n");
}
return 0;
}在以上代码中*(parr + i)是先找到数组名，也可以写成parr[i];后*(*(parr + i) + j) 就能找到数组内的元素，也可以写成parr[i][j]
上述的代码模拟出二维数组的效果，实际上并非完全是二维数组，因为每一行并分非是连续的
以上就深入理解指针(2)的全部内容，希望看完以上内容你能有所收获，接下来还会继续更新指针的其他内容，未完待续....
