在前几篇文章中，我们讲普通指针，数组指针，函数指针，这一篇文章我们将讲解C语言指针的其他应用，包括typedef关键字，回调函数。
目录
一 typedef关键字
typedef是C语言中的一个关键字，其全称是type define，顾名思义，这个关键字的作用是来定义类型的，但是不是用来定义新的数据类型，而是把其他数据类型（int，float等）重新定义为其他名字，使得类型书写起来更加简便，如：
typedef int zhengshu;
上述代码的作用是把int类型重新命名为了zhnegshu，所以如果写了这段代码，那么以后创建整形变量就可以这样写了：
#include<stdio.h>
typedef int zhengshu;
int main()
{
zhengshu a = 20;
printf("%d\n", a);
return 0;
}运行结果是：
typedef关键字并不只是限于把int类型重新命名为其他名字，是可以把任何类型命名为其他名字，如：
typedef char zifu;
typedef char* pc;
typedef int* pi;
typedef float xiaoshu;所以可以看到也是可以把指针类型命名为其他名字的，那么我们知道C语言中类型最复杂的就是数组指针和函数指针了，如果可以把这两种类型通过typedef关键字重新命名，就写起来特别简便，但是需要注意的一点的是重新命名的名字必须写在()里*的旁边，如：
#include<stdio.h>
typedef int(*parr)[5];
typedef int(*pf)(int,int);
int Add(int x,int y)
{
return x + y;
}
int main()
{
int arr[5] = {1, 2, 3, 4, 5};
parr p1 = &arr;
pf p2 = Add;
int ret = p2(**p1, *(*p1 + 1));
printf("%d\n", ret);
return 0;
}运行结果是：
上述代码中创建了一个5个整形数组的数组指针p1，返回值类型为int，参数个数为2，参数类型都为int的函数指针p2，然后把arr数组的地址赋给了p1，Add函数的地址赋给了p2，然后通过p2指针调用了Add函数，然后实参为**p1和*(*p1 + 1)，p1代表的是&arr，所以*p1就相当于*&arr，所以是arr数组名，而数组名又代表首元素地址，所以*p1其实代表的是arr数组首元素的地址，故**p1就是arr数组中的第一个元素，*(*p1 + 1)就代表数组中的第二个元素。
用typedef关键字还有一个好处，如：
int main()
{
int* a,b;
return 0;
}这并表示创建了两个int*指针类型的a,b变量，而是创建了一个int*指针类型的a，int类型的b，如果想要创建两个int*指针类型的变量a,b，需要这样写代码：
int* a,*b;而如果用typedef关键字定义了类型，就可以这样写了：
typedef int* pi;
int main()
{
pi a,b;
return 0;
}这样就代表创建了两个int*指针类型的变量a,b。
但是使用typedef关键字重定义类型，有一个坏处就是，重定义之后的类型会造成类型的直观性降低，降低代码阅读的直观性。
二 回调函数
1 回调函数的概念
函数指针有一中特殊的应用就是回调函数，所谓回调函数，就是一个通过函数指针调用的函数。
当把一个函数指针作为参数传递给另一个函数，当这个指针被用来调用函数时，被调用的函数就是回调函数。所以我们可以看到，回调函数并不是直接调用，而是在发生一定条件时，才会通过函数指针来调用。
回调函数举例（计算机的模拟实现）：
#include<stdio.h>
void meun()
{
printf("*******************\n");
printf("** 1. Add 2. Sub **\n");
printf("** 3. Mul 4. Div **\n");
printf("** 0. exit **\n");
printf("*******************\n");
}
int Add(int x,int y)
{
return x + y;
}
int Sub(int x,int y)
{
return x - y;
}
int Mul(int x,int y)
{
return x * y;
}
int Div(int x,int y)
{
return x / y;
}
void Calc(int(*pf)(int,int))
{
int x = 0;
int y = 0;
printf("请输入要操作的两位数：");
scanf("%d%d", &x, &y);
return pf(x,y);
}
int main()
{
int input = 1;
do
{
meun();
printf("请选择：");
scanf("%d", &input);
switch (input)
{
case 1:
Calc(Add);
break;
case 2:
Calc(Sub);
break;
case 3:
Calc(Mul);
break;
case 4:
Calc(Div);
case 0:
printf("exit\n");
break;
default:
printf("输入错误，请重新输入\n");
}
}while(input);
return 0;
}运行结果是：
在这个计算器实现代码中，是在input变量取不同值时，分别把Add，Sub，Mul，Div函数的地址传给Calc函数，然后通过函数指针调用每个函数，所以Add，Sub，Mul，Div这四个函数就被称为回调函数。
2 qsort函数
C语言中有一个库函数就是一个回调函数的具体应用，就是qsort库函数（需要包含头文件stdlib.h），接下来就来学习一下如何使用这个函数以及具体实现。
1） 使用
先看一下qsort函数的模型以及参数描述：
从函数模型来看，qsort函数能够实现任意类型数据的排序，比如整形，浮点型，甚至是结构体类型，这个函数一共有四个参数：
（1）void* base参数：这个参数是用来指向想要排序的数组的首元素的一个指针。
（2）size_t num参数：这个参数是要排序的数组中有几个元素。
（3）size_t size参数：这个参数是要排序数组中一个元素的大小，单位是字节。
（4）int(*compar)(const void*,const void*)参数：这是个函数指针类型的参数，其所指向的compar函数返回值为int类型，两个参数都是const void*指针类型，假设第一个参数为p1，第二个参数为p2，compar函数返回值如果大于0，说明p1指向的元素大于p2指向的元素，如果等于0，说明相等，如果小于0，说明小于。
根据参数来看，qsort函数默认是排成升序的。
接下来我们就来使用一下qsort函数。
排序整形数据：
#include<stdio.h>
#include<stdlib.h>
int Compar_int(void* e1,void* e2)
{
return *(int*)e1 - *(int*)e2;
}
int main()
{
int arr[] = {2, 1, 4, 3, 5, 6, 7, 10, 9, 8};
int sz = sizeof(arr)/sizeof(arr[0]);
qsort(arr, sz, sizeof(int), Compar_int);
int i = 0;
for (i = 0;i < sz;i++)
{
printf("%d ", arr[i]);
}
return 0;
}运行结果是：
需要注意的是，在使用qsort函数的时候提供的compar函数，其返回类型必须为int，参数类型必须为void*，但是void*类型的指针是不能进行解引用和加减整数操作的，所以必须把参数的两个指针强制类型转换为int*指针类型才可以。
如果想要降序输出的话，只需要把Compar_int函数的逻辑返一下就可以了，即改为e2-e1就可以实现降序排列了。
排序结构体数据：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct Stu
{
int age;
char name[20];
};
int Compar_struct_by_age(void* e1, void* e2)
{
return (*(struct Stu*)e1).age - (*(struct Stu*)e2).age;
}
int Compar_struct_by_name(void* e1, void* e2)
{
return strcmp(((struct Stu*)e1) -> name, ((struct Stu*)e2) -> name);
}
int main()
{
struct Stu arr[] = { {18, "zhangsan"}, {16, "lisi"}, {30, "wangwu"} };
int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr, sz, sizeof(struct Stu), Compar_struct_by_age);
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d %s\n", arr[i].age, arr[i].name);
}
printf("\n");
qsort(arr, sz, sizeof(struct Stu), Compar_struct_by_name);
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d %s\n", arr[i].age, arr[i].name);
}
printf("\n");
return 0;
}
运行结果是：
在这个代码中提供了两种结构体比较的方式，一种是按年龄排序，一种是按名字排序，注意字符串的比较不能直接用不等号进行比较，要用一个库函数strcmp(需要包含头文件string.h)来进行比较，该函数原型如下：
返回值：
2) 模拟实现
接下来我们来模拟实现一下qsort函数（原库函数是以快速排序算法实现，这里使用冒泡排序算法实现）：
我们先来了解一下冒泡排序算法：
冒泡排序算法的核心思想是两两比较，如果是要升序排列的话，只要要比较的前一个数字大于后面的那个数字就把他们交换，代码是：
#include<stdio.h>
void bubble(int arr[], int sz)
{
int i = 0;
for (i = 0;i < sz - 1;i++)//冒泡排序的趟数
{
int j = 0;
int flag = 1;//假设数组已经有序
for (j = 0;j < sz-1-i;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)
return;
}
}
int main()
{
int arr[] = {1, 3, 5, 2, 10, 8, 9, 6, 4, 7};
int sz = sizeof(arr)/sizeof(arr[0]);
bubble(arr, sz);
int i = 0;
for (i = 0;i < sz;i++)
{
printf("%d ", arr[i]);
}
return 0;
}运行结果是：
有了冒泡排序的基础，我们就可以来模拟实习qsort函数了。
用冒泡排序算法实现qsort函数时，要改的部分就只有交换元素以及相邻元素比较的部分，其余部分是不用改的，所以关键就在于如何找到要比较的两个相邻元素，两个相邻元素交换的条件以及如何把他们进行交换。
首先是找到两个要比较的参数，这时候我们就来从参数入手，参数中传了数组首元素的地址，还有每个元素字节的大小，那么找到要比较的两个相邻元素，其实就是找到两个元素的起始地址，然后就能通过指针找到那两个元素，而类比整形数组找到每个元素的方法，就是用首元素地址加减整数来找到每个元素的地址，我们知道一个整形元素是4个字节，所以其实是首元素地址跳过了4个字节，找到了下一个元素，根据此方法，我们就可以用参数中的base参数，先把base指针强转为char*类型的指针，这样每次加1就会跳过一个字节，然后每次加上j*size个字节，就能找到要排序数组中的要比较的相邻元素了。
其次就是找到的两个元素在什么条件下进行交换，还是从参数入手，可以看到库函数qsort参数中传了一个函数指针compar，那么我们就可以用这个函数来实现元素交换的条件判断。在冒泡排序算法中，如果要升序排序，是前面的元素大于后面的元素，那么就交换，而compar函数正好就是返回值大于0，说明前一个元素大于后一个元素，所以条件判断我们可以用compar函数，参数是找到的两个相邻元素，如果返回值大于0，那么我们就交换。
最后就是如何进行两个元素的交换了，这里我们可以设计一个Swap函数用来交换元素，参数肯定要包括交换两个元素的指针，那么是否还需要其他参数呢？这里我们可以想一下，这里如果要交换两个元素，我们不知道要排序的原数组是什么类型的数组，可能是结构体类型，可能是整形类型，所以这里我们不能采用元素直接交换的方式，而应该采取字节与字节之间交换的方式，那么就应该传递第三个参数，就是每个元素的字节数大小size，进行一个循环，循环szie次，每次交换一个字节就实现了元素的交换。
代码实现：
#include<stdio.h>
int compar_int(void* e1, void* e2)
{
return *(int*)e1 - *(int*)e2;
}
void Swap(size_t sz, char* e1, char* e2)
{
int i = 0;
for (i = 0;i < sz;i++)
{
char tmp = *(e1 + i);
*(e1 + i) = *(e2 + i);
*(e2 + i) = tmp;
}
}
void bubble_qsort(int* base, size_t num, size_t size, int(*compar)(void*, void*))
{
int i = 0;
for (i = 0;i < num - 1;i++)//冒泡排序的趟数
{
int j = 0;
int flag = 1;//假设数组已经有序
for (j = 0;j < num-1-i;j++)//每趟排序比较的对数
{
if (compar((char*)base+j*size, (char*)base+(j+1)*size)>0)//升序，降序只需改为<0
{
flag = 0;//进行交换了，数组是无序的
Swap(size, (char*)base+j*size, (char*)base+(j+1)*size);
}
}
if (flag == 1)
return;
}
}
int main()
{
int arr[] = {1, 3, 5, 2, 10, 8, 9, 6, 4, 7};
int sz = sizeof(arr)/sizeof(arr[0]);
bubble_sort(arr, sz, sizeof(int), compar_int);
int i = 0;
for (i = 0;i < sz;i++)
{
printf("%d ", arr[i]);
}
return 0;
}运行结果是：
到这里整个指针的讲解就结束了，共分为了4篇文章，下篇文章中我们将会讲解字符串相关函数以及内存相关函数，请尽请期待。
扫一扫
612
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
