C语言关于指针的知识（进阶）

一、字符指针

顾名思义，就是指向字符的指针
例如：int main() { const char* p = "hello"; printf("%s\n", pstr); return 0; }
这里其实只是把字符串“hello”的首个字符地址放到了指针p当中，而不是把字符串放进去。这里有一道例题：

int main()
{
    char str1[] = "hello";
    char str2[] = "hello";
    const char *str3 = "hello";
    const char *str4 = "hello";
    if(str1 ==str2)
 printf("str1 and str2 are same\n");
    else
 printf("str1 and str2 are not same\n");
       
    if(str3 ==str4)
 printf("str3 and str4 are same\n");
    else
 printf("str3 and str4 are not same\n");
       
    return 0;
}

大家可以想一下判断后打印出来是相同还是不同的。

揭晓答案：这里str1和str2是不同的，而str3和str4是相同的，为什么呢？因为这里str3和str4指向的是一个同一个常量字符串。C/C++会把常量字符串存储到单独的一个内存区域，当几个指针。指向同一个字符串的时候，他们实际会指向同一块内存。但是用相同的常量字符串去初始化
不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同，str3和str4相同。

二、指针数组

接下来我们来看指针数组，很多人容易把它和数组指针搞混淆，这里交给大家一个方法，你把指针和数组中间加一个“的”字，就变成了指针的数组，所以重点就在数组上了。
例如int * p[10]={int *p1,int * p2},这里p先和[]结合就说明了这是一个数组。

三、数组指针

3.1定义

我们来看数组指针：
顾名思义就是指向数组的指针；例如
char（* p）[2]就说明了p是指向char*[2]类型的指针，这里*操作符必须和p用括号括起来，因为[]的优先级高于 *，这个 *就说明了p是一个指针。

3.2关于&数组名和数组名的区别

很多人也很容易把&数组名和数组名搞混淆，我们都知道数组名表示的就是首元素的地址，那&数组名又是什么意思呢？我们来看接下来这段代码
：int main() { int arr[10] = { 0 }; printf("arr = %p\n", arr); printf("&arr= %p\n", &arr); printf("arr+1 = %p\n", arr+1); printf("&arr+1= %p\n", &arr+1); return 0; }
大家想一下这个代码运行的结果是什么呢？

所以看出来了吗，&数组名进行+1计算后跳过了整个数组的地址，因为十六进制的CC和A4相差了40个字节，所以我们可以得出**&数组名得到的是整个数组的地址，而不是首元素的地址了**，而这里&arr的类型就是int(*)[10],是数组指针的类型

四、指针传参数

4.1一级数组的传参

我们来想一个问题，当一个函数参数为一级指针的时候，能接收什么参数呢？

void test1(char *p)
{
}
char ch='2';
char * ptr=&ch;
char arr[]="abc";

经过我们对函数以及数组的了解我们知道可以写为
test(&arr);test(ptr);test(arr)这三种形式

4.2二级数组的传参

继续来想，当一个函数参数为二级指针的时候，又能接收什么参数呢？

void test(char **p)
{
 
}
int main()
{
 char c = 'b';
 char*pc = &c;
 char**ppc = &pc;
 char* arr[10];
}

同理我们知道可以写成

char* arr[10];
 test(&pc);
 test(ppc);
 test(arr);

这三种形式

五、函数指针

同理我们可以知道函数指针就是指向函数的指针

#include <stdio.h>
void test()
{
 printf("hehe\n");
}
int main()
{
 printf("%p\n", test);
 printf("%p\n", &test);
 return 0;
}

这儿有一段代码，我们直接用地址形式打印test函数和把函数地址取出来再打印，

我们能看到两种方式打印出来的地址是相同的。
那么函数的地址是如何保存的呢？这就要请出我们的函数指针了
我们规定函数指针的形式如下void(* p)()说明p是指针，指针指向的是一个函数，指向的函数无参
数，返回值类型为void。

六、 函数指针数组

那要把函数的地址放到一个数组中，这个数组就叫做函数指针数组，那么是如何定义的呢？
像上一个函数，我们只需要在指针的后面加上[x]即可，x表示几个元素：void(* p[5])(),这里p先和优先级高的[]结合说明这是一个数组，然后再和*结合，说明这个数组的类型是void *().这种数组有什么用呢？
举一个例子：

#include <stdio.h>
int add(int a, int b)
{
    return a + b;
}
int sub(int a, int b)
{
    return a - b;
}
int mul(int a, int b)
{
    return a * b;
}
int div(int a, int b)
{
    return a / b;
}
int main()
{
    int x, y;
    int input = 1;
    int ret = 0;
    do
    {
        scanf("%d", &input);
        switch (input)
        {
        case 1:
            printf("输入操作数：");
            scanf("%d %d", &x, &y);
            ret = add(x, y);
            printf("ret = %d\n", ret);
            break;
        case 2:
            printf("输入操作数：");
            scanf("%d %d", &x, &y);
            ret = sub(x, y);
            printf("ret = %d\n", ret);
            break;
        case 3:
            printf("输入操作数：");
            scanf("%d %d", &x, &y);
            ret = mul(x, y);
            printf("ret = %d\n", ret);
            break;
        case 4:
            printf("输入操作数：");
            scanf("%d %d", &x, &y);
            ret = div(x, y);
            printf("ret = %d\n", ret);
            break;
        case 0:
            printf("退出程序\n");
            break;
        default:
            printf("选择错误\n");
            break;
        }
    } while (input);

    return 0;
}

这个代码我们用来实现加减乘除四运算，但是我们可以看到这样的代码非常繁冗，所以我们就想能不能把这四个函数封装到一个数组里呢，要用的时候直接用函数指针来选择调用的函数，所以就有了以下的代码 （我们规定input为1，2，3，4的时候分别计算加减乘除）


因为我们只能选择1~4的数字，而数组的下标是0 ~4，所以我们在数组中加上0；
优化后的代码极大减少了之前的冗杂，

七、指向函数指针数组的指针

有了函数指针数组自然就有了指向它的指针,假定有这样一个函数

void test(const int * p)

那么它的函数指针就是void (*ptr)(const int * )
它的函数指针的数组就是void （*ptr[5]）(const int * )
那就很明确了指向该数组的指针就是void( *（*ptr)[5]）(const int * )

八、回调函数

接下来我们来了解什么是回调函数，回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。简单来说就是先把函数的地址传给另一个函数，等到使用者想什么时候用了就调用它，那么它就叫回调函数。
下面我们来了解以下qsort函数的使用方法，这个函数是对数组的元素进行排序，不管你给的数组是什么类型都可以。默认升序排序
通过查询我们知道了下面是它使用的参数

void qsort (void* base, size_t num, size_t size,
            int (*compar)(const void*,const void*));
            

其中void *base指向要排序的数组的第一个对象的指针，转换为 void * .
size_t num是数组中的元素个数,size_t size是每个元素的大小，因为存放数据的时候，我们不知道它传过来的数组是什么类型，但必须知道它的长度对吧，长度就包括了每个元素的大小，以及有多少个元素，最后int ( * compar)(const void * ,const void *)指向比较两个元素的函数的指针
而这个函数的返回类型是怎么定义的呢

因为是默认升序排序的，所以我们可以把两个指针进行相减，就像上图所说的，返回p1-p2，如果差值小于0，那么就把p1排到p2之前，而>0就把p1放到p2的后面。
下面我们就用这个函数来写一个排序一个数组的代码

int int_cmp(const void * p1, const void * p2)
{
  return (*( int *)p1 - *(int *) p2);
}
int main()
{
    int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
    int i = 0;
    
    qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof (int), int_cmp);
    for (i = 0; i< sizeof(arr) / sizeof(arr[0]); i++)
   {
       printf( "%d ", arr[i]);
   }
    printf("\n");
    return 0;
}

解释这里的 return (*( int *)p1 - *(int *) p2);是把地址p1强制类型转化成int*然后再解引用，得到该地址的元素，然后再进行交换。
有同学就问了，那怎么进行降序排列呢，其实很简单，我们只需要把return那一行的p1和p2交换一下顺序就行了。

以上就是关于指针的知识，如有漏洞差错，欢迎指正，如果可以，可以点上一个赞，关注我，未来带你了解更多知识！