深入理解指针(2)

在上一篇深入理解指针(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]