学习——理解指针（2）

一、数组名的理解

        <1>一维数组

        通过之前的学习，我们知道了可以通过&arr[0]（取地址操作）来取得数组首元素的地址，但是，数组名其实本来就表示数组首元素的地址

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

可以看到，arr与&arr[0] 所表示的地址一样，所以，数组名就是首元素的地址。

既然数组名就是首元素的地址，那么看以下代码

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

输出结果为 40，如果这里数组名表示首元素地址，不应该输出4\8吗？

其实，数组名表示首元素的地址，但是有两个例外：
1. sizeof(数组名)：数组名单独放在sizeof中，这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节。

2. &数组名：这⾥的数组名表⽰整个数组，取出的是整个数组的地址（整个数组的地址和数组⾸元素地址是有区别的）。

        <2>二维数组

一维数组的数组名是数组首元素的地址，那二维数组呢？也是首元素的地址吗？

二维数组的理解：

        把二维数组的每一行理解成一个一维数组，arr[0]就是第一行这个数组的数组名这样，二维数组里就存放着几个一维数组，二维数组的首元素就是第一行这个数组arr[0]。

        二维数组数组名其实表示的是第一行这个数组的地址。

二、使用指针访问数组

#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));
 }
 return 0;
}

    我们知道，这里数组名就是首元素的地址，而指针变量p存放的也是数组首元素的地址，那么，可不可以对数组名直接进行解引用操作呢，可不可以通过p[i]来访问数组中的数据呢？

        

#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]); //*(arr+i)
 }
 return 0;
}

这样代码可以正常运行并输出的，所以本质上p[i]就等价与*(p+i)。

        同理arr[i]也是等价与*(p+i)。数组元素的访问在编译器处理的时候，也是转换成⾸元素的地址+偏移量(整数)求出元素的地址，然后解引⽤来访问的。

三、数组传参的本质

       

#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)其实就是对一个地址求大小（单位是字节）。

        一维数组传参的本质：一维数组传递的是数组首元素的地址。

        二维数组传参的本质：二维数组传递的是第一行这个数组的地址。

      对于二维数组，看以下代码：

#include <stdio.h>
void test(int (*p)[5], int r, int c)
{
    int i = 0;
    int j = 0;
    for(i=0; i<r; i++){
        for(j=0; j<c; j++){
            printf("%d ", *(*(p+i)+j));
        }
        printf("\n");
    }
}
int main()
{
 int arr[3][5] = {{1,2,3,4,5}, {2,3,4,5,6},{3,4,5,6,7}};
 test(arr, 3, 5);
 return 0;
}

        在函数tset中，出现了*(*(p+i)+j);  当我们知道了二位数组传参本质，理解起来就简单了

p是数组第一行的地址，p+i就是第i行的地址，对其进行解引用，就找到第i行这个一维数组，

*(p+i)+j 就是在第i行中找到第j个元素，然后对其解引用，就找到了第i行第j个元素。也可以直接写成p[i][j];

四、冒泡排序

冒泡排序就是，相邻的两个元素进行比较，最后实现排序

void bubble_sort(int arr[], int sz)//sz参数接收数组元素个数
{
 int i = 0;
 for(i=0; i<sz-1; i++)
 {
 int j = 0;
 for(j=0; j<sz-i-1; j++)
 {
 if(arr[j] > arr[j+1])
 {
 int tmp = arr[j];
 arr[j] = arr[j+1];
 arr[j+1] = tmp;
 }
 }
 }
}
int main()
{
 int arr[] = {3,1,7,5,8,9,0,2,4,6};
 int sz = sizeof(arr)/sizeof(arr[0]);
 bubble_sort(arr, sz);
 int i = 0;
 for(i=0; i<sz; i++)
 {
 printf("%d ", arr[i]);
 }
 return 0;
}

这样写你会发现，如果我这个数组一开始就是有序的，或者排序过程在有序了，但是这个排序循环还是一直在进行。需要想办法进行判断这个数组是否有序，如果已经有序，循环就停下来。

void bubble_sort(int arr[], int sz)//参数接收数组元素个数
{
 int i = 0;
 for(i=0; i<sz-1; i++)
 {
 int flag = 1;//假设这⼀趟已经有序了
 int j = 0;
 for(j=0; j<sz-i-1; j++)
 {
 if(arr[j] > arr[j+1])
 {
 flag = 0;//发⽣交换就说明，⽆序
 int tmp = arr[j];
 arr[j] = arr[j+1];
 arr[j+1] = tmp;
 }
 }
 if(flag == 1)//这⼀趟没交换就说明已经有序，后续⽆序排序了
 break;
 }
}
int main()
{
 int arr[] = {3,1,7,5,8,9,0,2,4,6};
 int sz = sizeof(arr)/sizeof(arr[0]);
 bubble_sort(arr, sz);
 int i = 0;
 for(i=0; i<sz; i++)
 {
 printf("%d ", arr[i]);
 }
 return 0;
}

五、指针数组

我们知道，一个整形数组，存放的都是整型数组；一个字符数组，存放的都是字符；

那存放指针类型的数组，其实就是指针数组。

指针数组中每一个元素都是地址，又可以指向一块内存。

六、指针数组模拟二维数组

#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]就是整型⼀维数组中的元素。

        对于二维数组，用指针数组也可以来实现二维数组，但是指针数组中每个元素所指向的一维数组不是连续的。