C语言指针高级用法

C语言精髓是指针，指针知识深似海，遇到一些学习一些~

---

0. 指针基础

指针与底层硬件联系紧密，使用指针可操作数据的地址，实现数据的间接访问。
0.1. 变量与指针
变量存储在内存里；
指针保存的是地址，32位处理器中的地址都是32位的，无论是什么类型的指针变量，都是4字节。

0.2. 指针的操作
如果已经定义：

int a;
int *p;

则对指针p有如下操作方式：

0.3. 结构体指针
定义如下的结构体：

typedef struct student
{
	char *name;
	int age;
	struct student *classmate;
}student, *pstudent;

定义两个具有该结构体属性的学生：

student s1 = {
	"s1",
	18,
	NULL // 等后面再去赋值
};
student s2 = {
	"s2",
	19,
	NULL // 等后面再去赋值
};

我现在想让他俩成为同桌，需要如下操作：

s1.classmate = &s2; // 对s2取址，因为classmate成员本身就是一个指针
s2.classmate = &s1;

printf("s1's classmate is :%s\r\n", s1.classmate->name);

通过上面的例子，引出结构体的某个成员使用“.”，访问指针的成员使用“->”。

1. typedef 定义函数指针类型

函数参数化是指通过函数指针将函数的某些行为参数化。这样，我们可以在调用函数时动态地指定函数的行为。以下是一个示例：

#include <stdio.h>

void process_array(int *array, size_t size, int (*process)(int))
{
    for(size_t i = 0; i < size; i++)
    {
        array[i] = process(array[i]);
    }
}

int increment(int n)
{
    return n * 2;
}


int main()
{
    int array[] = {1, 2, 3, 4, 5};
    size_t size = sizeof(array) / sizeof(int);
    process_array(array, size, increment);
    for(size_t i =0; i < size; i++)
    {
        printf("%d", array[i]);
    }
    printf("\n");
    return 0;
}

如果通过typedef来定义函数指针类型：

#include <stdio.h>

typedef int (*process_t)(int);

void process_array(int *array, size_t size, process_t process)
{
    for(size_t i = 0; i < size; i++)
    {
        array[i] = process(array[i]);
    }
}

int increment(int n)
{
    return n * 2;
}


int main()
{
    int array[] = {1, 2, 3, 4, 5};
    size_t size = sizeof(array) / sizeof(int);
    process_array(array, size, increment);
    for(size_t i =0; i < size; i++)
    {
        printf("%d", array[i]);
    }
    printf("\n");
    return 0;
}

定义的 process_array 函数接受三个参数：一个整型数组、数组大小、一个函数指针。函数指针指向一个函数，该函数接受一个整型参数并返回一个整型结果。因此，当执行到 array[i] = process(array[i]); 时，process函数会自动调用increment函数。
有人可能会问了：“那如果我再定义一个函数：int aaaa(int x){return x + 1;}呢？process 函数会调用哪个函数？”。
这样符合 process_t 类型的函数就有多个了，我们可以将 process 指针指向某个函数，比如：

process_t process = aaaa; // 设置 process 指针指向 aaaa 函数
process_array(array, size, process);

2. void* 空指针的解引用

首先定义一个uint32_t 类型的param_value ，其值为0xa5a5，现在已经通过某种方法将 param_value 的地址指针传入了函数 sys_manager_handler 中（第三个参数），我们需要关注的是如何在函数内使用printf将 param_value 这个值打印出来。
在printf中，应该使用何种占位符？param作为一个指针又应该如何变换？
伪代码如下：

uint32_t param_value = 0xa5a5;

int sys_manager_handler(void *cobj, uint32_t event_id, void *param)
{
    printf("we got value from event:%lx", *(uint32_t *)param);
    printf("sys_manger got value from event:%lx", *param);
}

以上两句 printf 哪个正确？
由于我们知道，传入函数的第三个参数 param 是一个指向 param_value 地址的指针，所以我们在 printf 中的变量处需要对 param 指针进行解引用，得到一个 uint32_t 类型的变量，对应的占位符使用 %lx 就好啦。
但其实直接对 param 进行解引用是不对的，因为：

• void * 类型的指针可以指向任何类型的数据，对应地，这样的指针并没有具体的类型信息，所以编译器也不知道它指向的数据的类型和大小。
• 当需要访问void *指针所指向的数据时，必须先将其转换为具体的指针类型，然后才能解引用。

综上，正确的是第一句。

printf("we got value from event:%lx", *(uint32_t *)param);

3. 函数指针数组

数组中的每个元素都是一个函数指针，根据输入参数的不同，动态地调用不同的函数。

#include <stdio.h>

void add(int x, int y)
{
    printf("%d + %d = %d\r\n", x, y, x+y);
}

void multiply(int x, int y)
{
    printf("%d * %d = %d\r\n",  x, y, x*y);
}

typedef void (*operation_func_t)(int, int);

int main()
{
    operation_func_t operations[] = {add, multiply};
    size_t num_opt = sizeof(operations) / sizeof(operation_func_t);
    int a = 10;
    int b = 5;
    for(size_t i = 0; i < num_opt; i++)
    {
        operations[i](a, b);
    }
    return 0;
}

在operations数组中遍历调用这个数组里的函数，这样做的好处是省去了选择函数的繁琐，之一应用场景为“用户通过按键来选择运算的符号，在函数逻辑中省去了繁长的case语句”。

4. 结构体函数指针

C语言的结构体里包含了成员（各种类型的变量），但是成员不能是函数，为了弥补这一缺点，可以使用指向函数的指针。

#include <stdio.h>  
      
typedef struct  
{  
    int a;  
    void (*pshow)(int);  
}TMP;  
      
void func(TMP *tmp)  
{  
    if(tmp->a >10)
    {  
        (tmp->pshow)(tmp->a);  
    }  
}  
      
void show(int a)  
{  
    printf("a==%d\n",a);  
}  
      
void main()  
{
    TMP test;  
    test.a = 11;  
    test.pshow = show;  
    test.pshow(test.a); // (1)
    func(&test);   // (2)
}  

终端显示：
a==11 (1)
a==11 (2)