指针进阶——看这个就够了

字符指针

字符指针，简单点来说就是用指针可以表示一个字符串，因为在调用字符串的时候是将字符串的首地址拿过来，然后在依次向后读取的，直到遇到空字符'\0'；

指针数组

1.定义：是一个存放指针的数组，可以结合一维数组模拟实现二维数组

2.表示形式： 数据类型 * 数组名[];

parr本身是一个数组名，其含有三个元素，*(parr+i)可以将&arr1，&arr2，&arr3依次得到，再对*(parr+i)进行解应用，就可以得到arr1，arr2，arr3里面的元素。又因为*(parr+i)可以写成parr[i],而

*（parr[i]+j）又可以写成parr[i][j]，由此，以上代码可以改写为

数组指针

1.定义：存放整个数组地址的指针

2.表示：int (*p)[10]；

先和*结合，说明这是一个指针，又和[ ]结合，表示p是指向一个数组的指针，且该数组中有十个元素，每个元素是int,所以其基类型为int (*)[10]；

3.数组首元素

数组首元素通常都是数组首元素的地址，但是有两个情况是例外的。

1. 一个是【sizeof(数组名)】,此时计算的是整个数组的大小，而不仅仅是首元素的地址.

2. 二是【&数组名】，这里的数组名的大小虽然仍然是首元素地址，但是对其进行+-操作时，其值的变化是以整个数组的字节数为变化的。

通过简单的计算，可以计算出第二个图片中地址之间的差值确实是40

数组参数、指针参数

1.一维数组传参

第一种：

#include <stdio.h>
int sum_f(int arr[])
{
    int sum = 0;
    for (int i = 0; i < 10; i++)
        sum = sum + arr[i];
    return sum;
}
int main()
{
    int arr[]={1,2,3,4,5,6,7,8,9,10};
    int ret = sum_f(arr);
    printf("%d",ret);
    return 0;
}

第二种：

#include <stdio.h>
int sum_f(int* p)
{
    int sum = 0;
    for (int i = 0; i < 10; i++)
        sum = sum + *(p + i);
    return sum;
}
int main()
{
    int arr[10]={1,2,3,4,5,6,7,8,9,10};
    int ret = sum_f(arr);
    printf("%d",ret);
    return 0;
}

一维数组传递过去的是地址，可以直接使用同类型的指针去接收

2.二维数组传参

第一种

#include <stdio.h>
int sum_f(int arr[][4])
{
    int sum = 0;
    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 4; j++)
        {
            sum = sum + arr[i][j];
        }
    }
    return sum;
}
int main()
{
    int arr[][4] = {1,2,3,4,5,6,7,8,9,10,11,12};
    int ret = sum_f(arr);
    printf("%d",ret);
    return 0;
}

第二种

#include <stdio.h>
int sum_f(int(*p)[4])
{
    int sum = 0;
    for (int i = 0; i <3;i++)
    {
        for (int j=0; j<4;j++)
        {
            sum=sum+p[i][j];
        }
    }
    return sum;
}
int main()
{
    int arr[][4] = {1,2,3,4,5,6,7,8,9,10,11,12};
    int ret = sum_f(arr);
    printf("%d",ret);
    return 0;
}

3.一级指针传参

就相当于数组名传参，直接用指针变量接收就行。

#include <stdio.h>
void Modify(int *x)
{
    *x=20;
}
int main()
{
    int a=10;
    int*p=&a;
    Modify(p);
    printf("%d",a);
    return 0;
}

p的值就是地址，可以用一级指针变量接收这个地址即可

4.二级指针传参

二级指针可以通俗的理解为，储存一级指针变量地址的指针变量，对其进行两次解应用就可以得到其原本的值

#include <stdio.h>
void Modify(int **x)
{
    **x=20;
}
int main()
{
    int a=10;
    int*p=&a;
    int** p1 = &p;
    Modify(p1);
    printf("%d",a);
    return 0;
}

函数指针

1.对于函数来说，【&函数名】和【函数名】,都代表目前函数的地址
2.格式：函数返回值类型 (*)(参数类型一 ,参数类型二 )

函数指针，顾名思义就是指向函数的指针，读函数指针的声明，我们有更加严格的要求

一：返回值类型必须和函数的返回值类型相同
二：参数类型必须和函数的参数类型保持一致

#include <stdio.h>
int add(int x, int y)
{
    return x + y;
}
int del(int x, int y)
{
    return x - y;
}
int div(int x, int y)
{
    return x / y;
}
int mul(int x, int y)
{
    return x * y;
}
int Cacl(int x,int y,int (*p)(int ,int ))
{
    printf("%d\n",p(x,y));
}
int main()
{
    int a=10,b=10;
    Cacl(a,b,add);
    Cacl(a,b,del);
    Cacl(a,b,div);
    Cacl(a,b,mul);
    return 0;
}

函数指针的nb之处就在于能够让我们把函数作为参数，也称为回调函数，

函数指针数组

函数指针也是指针，可以类比成指针数组,是存放指针的数组
上面的代码还可以这样写

#include <stdio.h>
int add(int x, int y)
{
    return x + y;
}
int del(int x, int y)
{
    return x - y;
}
int div(int x, int y)
{
    return x / y;
}
int mul(int x, int y)
{
    return x * y;
}
int Cacl(int x,int y,int (*p)(int ,int ))
{
    printf("%d\n",p(x,y));
}
int main()
{
    int a = 10, b = 10;
    int (*p[])(int, int) ={0,add,del,div,mul};
    for (int i =1;i<= 4;i++)
    {
        Cacl(a, b, p[i]);
    }
    return 0;
}

p先和优先级比较高的[ ]结合，再和*结合，表明p是一个什么什么指针数组，再和int ()(int ,int )结合，说明他是一个函数指针数组

以qsort函数为例应用函数指针

首先我们引入以冒泡法为例的整数排序方法

#include <stdio.h>
void bubble(int arr[],int n)
{
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n - 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] ={1,2,3,4,5,6,7,8,9,10};
    int sz = sizeof(arr) / sizeof(arr[0]);
    bubble(arr,sz);
    for (int i = 0; i < sz; i++)
        printf("%d ", arr[i]);
    return 0;
}

这个排序是没有任何问题的，但是这种排序方法是比较笨拙的，它只能排序整数，能不能用我们前面学到的函数指针或者函数指针数组来让我们这个bubble函数能够排序任何我们想要排序的数据呢？

对qsort分析

1.第一个参数是要排序数据的首地址
2.第二个参数是要排序数据的个数
3.第三个参数是要排序数据单个数据的宽度
4.第四个参数中的_cdecl是一种命名规范，可以忽略不记。第四个参数就是函数指针

#include <stdio.h>
int cmp_Int(const void* e1, const void* e2)
{
    return (*(int*)e1-*(int*)e2);
}
void swap(char* p1, char* p2, int width)
{
    for (int i = 0; i<width; i++)
    {
        char tmp = *p1;
        *p1 = *p2;
        *p2 = tmp;
        p1++;
        p2++;
    }
}
void bubble(void *base,size_t num,size_t width,int(*cmp)(const void* e1, const void* e2))
{
    for (int i = 0; i <num-1; i++)
    {
        for (int j =0;j<num-1-i;j++)
        {
            if (cmp((char*)base+j*width,(char*)base+(j+1)*width)>0)
            {
                swap((char *)base+j*width,(char *)base+(j+1)*width,width);
            }
        }
    }
}
int main()
{
    int arr[10] ={1,6,3,4,7,9,2,4,6,9};
    int sz = sizeof(arr) / sizeof(arr[0]);
    bubble(arr,sz,sizeof(arr[0]),cmp_Int);
    for (int i = 0; i<sz; i++)
        printf("%d ",arr[i]);
    return 0;
}

手搓qsort函数，在这其中我们应用的就是函数指针，由此我们可以感受一下函数指针的用途