目录
前言
主题：指向函数的指针ex18
你理解函数指针吗？由指针到结构体指针再到函数指针，让我萌生一种万物皆指针的感觉！
正文
笨办法：
C语言中的函数实际上只是指向程序中某处代码的指针。就像你创建的指向结构体、字符串、数组的指针一样，你也能用指针指向函数。这么做的主要作用就是向其他函数传递回调函数（callback），或者模拟类与对象。
手把手：
函数指针大家了解一下就行了，用的不多，但一定要认识它。（哦，然也？！查找过程中，发现python里也有此类运用，所以……挺安慰人的，嘿嘿！）
如果在程序中定义了一个函数，那么在编译时系统就会为这个函数代码分配一段存储空间，这段存储空间的首地址为这个函数的地址。而且函数名表示的就是这个地址。既然是地址我们就可以定义一个指针变量来存放，这个指针变量就叫做函数指针变量，简称函数指针。（这解释感觉是真清晰!)
函数指针定义方式：函数返回值类型 （*指针变量名）（函数参描述列表）；
示例代码：
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
/** Our old friend die from ex17. */
void die(const char *message)
{
if (errno)
{
perror(message);
}
else
{
printf("ERROR: %s\n", message);
}
exit(1);
}
// a typedef creates a fake type, int this
// case for a function pointer
typedef int (*compare_cb)(int a, int b);
/**
*
* A classsic bubble sort function that uses the
* compare_cb to do the sorting.
*/
int *bubble_sort(int *numbers, int count, compare_cb cmp)
{
int temp = 0;
int i = 0;
int j = 0;
int *target = (int *)malloc(count * sizeof(int));
if (!target)
die("Memory error.");
memcpy(target, numbers, count * sizeof(int));
for (i = 0; i < count; i++)
{
for (j = 0; j < count - 1; j++)
{
if (cmp(target[j], target[j + 1]) > 0)
{
temp = target[j + 1];
target[j + 1] = target[j];
target[j] = temp;
}
}
}
printf("I:%d J:%d\n", i, j);
return target;
}
int sorted_order(int a, int b)
{
return a - b;
}
int reverse_order(int a, int b)
{
return b - a;
}
int strange_order(int a, int b)
{
if (a == 0 || b == 0)
{
return 0;
}
else
{
return a % b;
}
}
/**
* Used to test that we are sorting things correctly
* by doing the sort and printging it out;
*/
void test_sorting(int *numbers, int count, compare_cb cmp)
{
int i = 0;
int *sorted = bubble_sort(numbers, count, cmp);
if (!sorted)
die("Failed to sort as requested.");
for (i = 0; i < count; i++)
{
printf("%d ", sorted[i]);
}
printf("\n");
free(sorted);
}
int main(int argc, char *argv[])
{
if (argc < 2)
die("USAGE: ./ex18 4 3 1 5 6");
int count = argc - 1; // except ./ex18
int i = 0;
char **inputs = argv + 1; // cha 1
int *numbers = (int *)malloc(count * sizeof(int));
if (!numbers)
die("Memory error.");
for (i = 0; i < count; i++)
{
numbers[i] = atoi(inputs[i]);
}
test_sorting(numbers, count, sorted_order);
test_sorting(numbers, count, reverse_order);
test_sorting(numbers, count, strange_order);
free(numbers);
return 0;
} 在上面代码中我绝的最绕人的就是compare_cb没有定义代码块就能用，疙疙瘩瘩的……typedef int (*compare_cb) (int a, int b); ：声明了一个名为 compare_cb 的指针类型，该指针类型指向一个以两个 int 类型参数并返回 int 类型的函数。
可能要多用多理解！看了“后语D”感觉就好多了D.函数指针和指针函数的差别
附加任务：
再写一个排序算法，然后修改test_sorting， 让它可以接受任意排序函数以及排序函数的回调比较。用它来测试你的两个算法（感觉附加的都是牛牛题，应该是作者高屋建瓴的一种提问，让牛牛们没那么无聊吧！然后我就可以心安理得的继续下一章了，呵呵。本来想放弃的，但是我又倔了下）
解题思路：
- 排序算法有那些？
- 接受任意排序函数的实例？
- 怎么测试两个算法？
1、C语言中常用的排序算法有以下几种：
- 冒泡排序（Bubble Sort）
- 插入排序（Insertion Sort）
- 选择排序（Selection Sort）
- 快速排序（Quick Sort）
- 归并排序（Merge Sort）
- 堆排序（Heap Sort）
- 希尔排序（Shell Sort）
- 计数排序（Counting Sort）
- 桶排序（Bucket Sort）
- 基数排序（Radix Sort）
2、接受任意排序函数
在C语言中，可以使用函数指针来实现函数接受任意函数的功能。函数指针可以指向任意类型的函数，并可以作为参数传递给其他函数。下面是一个示例：
#include <stdio.h>
// 定义一个函数指针类型，该指针可以指向任意返回类型和参数的函数
typedef void (*FunctionPtr)();
// 接受函数指针作为参数的函数
void executeFunction(FunctionPtr fn) {
// 执行传入的函数
fn();
}
// 一个用于测试的函数
void myFunction() {
printf("Hello, World!\n");
}
int main() {
// 将myFunction的地址传递给executeFunction
executeFunction(myFunction);
return 0;
}
在上面的示例中，我们首先定义了一个函数指针类型FunctionPtr，它指向不返回任何值且不带任何参数的函数。然后，我们编写了一个名为executeFunction的函数，该函数接受一个函数指针作为参数，并在函数体内调用了传入的函数。最后，我们定义了一个名为myFunction的函数，用于测试。
在main函数中，我们将myFunction的地址传递给executeFunction函数。运行程序后，executeFunction会执行myFunction，输出"Hello, World!"。
通过函数指针，我们可以实现C语言中的函数接受任意函数的功能。可以根据实际需求定义函数指针类型并传递不同类型的函数指针。
3、测试算法？
附加任务代码：
// ...（之前的代码保持不变）
/**
* A classic insertion sort function that uses the
* compare_cb to do the sorting.
*/
int *insertion_sort(int *numbers, int count, compare_cb cmp)
{
for (int i = 1; i < count; i++)
{
int key = numbers[i];
int j = i - 1;
while (j >= 0 && cmp(numbers[j], key) > 0)
{
numbers[j + 1] = numbers[j];
j = j - 1;
}
numbers[j + 1] = key;
}
return numbers;
}
// 修改后的 test_sorting 函数
void test_sorting(int *numbers, int count, compare_cb cmp, void (*sort_func)(int *, int, compare_cb))
{
int *sorted = (int *)malloc(count * sizeof(int));
if (!sorted)
die("Memory error.");
memcpy(sorted, numbers, count * sizeof(int));
sort_func(sorted, count, cmp);
printf("Sorted: ");
for (int i = 0; i < count; i++)
{
printf("%d ", sorted[i]);
}
printf("\n");
free(sorted);
}
// ...（main函数中的其他代码保持不变）
int main(int argc, char *argv[])
{
// ...（main函数中的其他代码保持不变）
test_sorting(numbers, count, sorted_order, bubble_sort);
test_sorting(numbers, count, reverse_order, bubble_sort);
test_sorting(numbers, count, strange_order, bubble_sort);
test_sorting(numbers, count, sorted_order, insertion_sort); // 使用新的插入排序算法
free(numbers);
return 0;
}（以上是我从问答得到的gpt的回答，总感觉因为有了ai，人们开始浮躁了，你觉得呢？）
后语
- 带着函数也是一种指针的思想，我回头看了下ex17的Database_open，感觉思路又清晰了不少。也许ex18应该放在ex17前面。
-
笨笨的学系列笔记升级了，学习笔记的范围不再局限于”笨办法系列“ ，大家是不是喜大普笨呢？反正笔者很开心，这个决定感觉是上一篇007笔记给我的最大收获！
以前的笨是相对一本书的狭隘的笨，现在的笨方法升级为两本书 甚至三本抑或更多！愿你们能得到更多的收获！
-
按照“手把手”说法，两大难点（控制流，指针）已经接近尾声，下面即将进军算法了，好期待
-
附加是可以跳的，但是这也是我给自己留下的第二个坑。
-
如果大家有在用ai的话，请注意ai犯错的几率非常高，尤其程序都要自己上机调试一下。所以你想用好它，首先你要懂得它说的知识点，不然容易闹笑话。（实践是检验一切的真理！）
A.回调函数
看过以下的解释，感觉对回调函数及指向函数指针的应用理解更清晰了一些。
在C语言中，回调函数是指一个函数作为参数传递给另一个函数，并在该函数内部被调用的情况。
回调函数的实例可以通过以下示例来说明：
#include <stdio.h>
// 回调函数，用于处理数组元素
void processArray(int arr[], int size, void (*callback)(int)) {
for (int i = 0; i < size; i++) {
// 调用回调函数来处理当前元素
callback(arr[i]);
}
}
// 回调函数的实现，用于打印数组元素
void printNumber(int num) {
printf("%d ", num);
}
int main() {
int numbers[] = {1, 2, 3, 4, 5};
int size = sizeof(numbers) / sizeof(numbers[0]);
// 调用processArray函数，将printNumber函数作为回调函数传递
processArray(numbers, size, printNumber);
return 0;
}
在上面的示例中，我们定义了一个processArray函数，该函数接收一个整型数组、数组大小和一个函数指针作为参数。在processArray函数内部，使用一个循环遍历数组中的元素，并调用回调函数来处理每个元素。我们还定义了一个printNumber函数作为回调函数的实现，用于打印数组中的元素。
在main函数中，我们创建了一个整型数组numbers并调用了processArray函数，将numbers数组、数组大小和printNumber函数作为参数传递给processArray函数。在processArray函数内部，它会调用回调函数printNumber来处理数组中的每个元素，最终输出了数组中的元素。
这就是回调函数在C语言中的基本应用。通过回调函数的使用，我们可以将一些通用的操作封装在函数内部，并通过回调函数的方式来处理不同的具体操作。这样使得代码更加灵活和可重用。
B.模拟类与对象
（有点心念念python的类与对象，现在如果再去看下，是不是很轻松就理解了呢？(●'◡'●)）
在C语言中，没有直接的类和对象的概念，因为C是一种过程化编程语言。然而，可以使用结构体来模拟类和对象的概念。
一个结构体可以包含数据成员和函数成员，类似于类中的属性和方法。然后，可以通过创建结构体的实例来模拟对象的创建。
以下是一个简单的示例，演示如何在C中模拟类和对象：
#include <stdio.h>
// 定义一个结构体来模拟类
typedef struct {
int x;
int y;
// 定义函数成员
void (*print)(struct Point);
void (*move)(struct Point*, int, int);
} Point;
// 定义函数成员的实现
void printPoint(Point p) {
printf("Point coordinates: (%d, %d)\n", p.x, p.y);
}
void movePoint(Point* p, int dx, int dy) {
p->x += dx;
p->y += dy;
}
int main() {
// 创建一个Point对象
Point myPoint = {3, 5, printPoint, movePoint};
// 调用函数成员
myPoint.print(myPoint);
myPoint.move(&myPoint, 2, 3);
myPoint.print(myPoint);
return 0;
}
在上面的示例中，我们首先定义了一个结构体Point，它具有两个整型成员x和y，以及两个函数成员print和move。函数成员的参数和返回类型需要根据实际需要进行定义。
然后，我们在main函数中创建了一个Point对象myPoint，并通过初始化来设置其初始值和函数成员的指针。我们可以通过使用点运算符来访问对象的成员和函数，并对对象进行操作。
请注意，这只是一种简单的模拟类和对象的方法，并不像面向对象语言中那样完整和灵活。C语言的主要目标是提供一种高效的过程化编程方式，而不是面向对象的编程。（调试程序时发现了struct重命名的bug，才发现struct的花样还真多，下面一篇解释详细全面的C语言——结构体struct与typedef的使用_typedef struct-CSDN博客）
C.memcpy
memcpy是C语言中的一个库函数，它用于将一段内存的内容复制到另一段内存中。其原型如下：
void *memcpy(void *destination, const void *source, size_t num);
memcpy接受三个参数：
destination：指向目标位置的指针，即要将数据复制到的内存地址。source：指向源位置的指针，即要复制数据的内存地址。num：要复制的字节数。
memcpy的作用是将source指向的内存块中的内容复制到destination指向的内存块中，复制的字节数由num指定。
需要注意的是，memcpy函数是按字节进行复制的，不会检查数据类型。因此，要确保目标内存块足够大以容纳源内存块的内容。
以下是一个使用memcpy的示例：
#include <stdio.h>
#include <string.h>
int main() {
char str1[] = "Hello";
char str2[10];
// 将str1复制到str2中
memcpy(str2, str1, strlen(str1) + 1);
printf("str2: %s\n", str2); // 输出：str2: Hello
return 0;
}
在上述示例中，str1是源内存块，包含了字符串"Hello"。str2是目标内存块，长度为10。使用memcpy将str1复制到str2中，然后输出str2的内容，即"Hello"。
D.函数指针和指针函数的差别
函数指针和指针函数是两个不同的概念。
函数指针是指向函数的指针变量，可以用来存储函数的地址，从而可以通过函数指针调用相应的函数。函数指针的声明形式为：返回类型 (*指针变量名)(参数列表) 。
下面是一个函数指针的示例：
int add(int x, int y) {
return x + y;
}
int main() {
// 声明一个函数指针
int (*ptr)(int, int);
// 将指针指向add函数
ptr = add;
// 通过函数指针调用add函数
int result = ptr(3, 4);
printf("Result: %d\n", result);
return 0;
}
指针函数是一个返回指针的函数，在函数的定义中有一个指针类型的返回值。指针函数可以用来返回动态分配的内存或者指向其他数据的指针。指针函数的声明形式为：返回类型 *函数名(参数列表) 。
下面是一个指针函数的示例：
int* create_array(int size) {
int* arr = malloc(size * sizeof(int));
// 对数组进行初始化
for (int i = 0; i < size; i++) {
arr[i] = i;
}
return arr;
}
int main() {
int* arr = create_array(5);
// 使用指针函数返回的指针
for (int i = 0; i < 5; i++) {
printf("%d ", arr[i]);
}
printf("\n");
free(arr);
return 0;
}
总结： 函数指针是指向函数的指针变量，用于函数的调用；指针函数是返回指针的函数，用于返回指针或动态分配的内存。
扫一扫
963
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
