[习题18]C语言 回调函数：指向函数的指针 int (*POINTER_NAME) = (int a ,int b);

使用教材

《“笨办法” 学C语言（Learn C The Hard Way）》
https://www.jianshu.com/p/b0631208a794

函数指针语法

int (*POINTER_NAME) (int a ,int b);

• 首先，写一个普通的函数声明：int callme(int a, int b);
• 然后，用指针的语法格式包装函数名：int (*callme) (int a, int b)
• 把名字改为指针名：int (*compare_cb) (int a, int b);

此后，函数指针的变量名叫做compare_cb，可以像使用函数一样使用compare_cb

代码功能

• 命令行输入一组数字，进行冒泡排序，并输出排序结果；
• 排序规则 通过 指向函数的指针 传入决定；

ex18.c

#include 
#include 
#include 
#include 

/* 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, in this
// case for a funciton pointer
typedef int(*compare_cb)(int a, int b);

/**
*   A classic 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 = malloc(count * sizeof(int));
    
    if(!target) 
        die("Memory error.");
    
    memcpy(target, numbers, count * sizeof(int));
    
    for(i = 0 ; i < count; i++) {
        for(j = i+1 ; j < count-1; j++) {
            if(cmp(target[i], target[j+1]) > 0) {
                temp = target[j+1];
                target[j+1] = target[i];
                target[i] = temp;
            }
        }
    }
    
    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 printing 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;
    int i = 0;
    char **inputs = argv + 1;
    
    int *numbers = 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;
}

run

$ make ex18
clang -Wall -g    ex18.c   -o ex18
$ ./ex18 4 1 7 3 2 0 8
0 1 2 3 7 4 8 
8 7 4 3 2 0 1 
8 2 3 7 4 0 1 

回调函数 callback

typedef int(*compare_cb)(int a, int b);

• typedef int(*compare_cb)(int a, int b); ， typedef使cmpare_cb可以作为一个类型来使用；

• int *bubble_sort(int *numbers, int count, compare_cb cmp){} ，传入参数里面有一个cmpare_cb型的变量，叫做cmp；

• void test_sorting(int *numbers, int count, compare_cb cmp){}，传入参数里面有一个cmpare_cb型的变量，叫做cmp；

• int sorted_order(int a, int b){} ，一个很普通的函数，函数名叫做sorted_order；

• test_sorting(numbers, count, sorted_order); ，告诉编译器，现在要用函数sorted_order；

• if(cmp(target[i], target[j+1]) > 0) 等价于if(sorted_order(target[i], target[j+1]) > 0)，现在哪里可以用函数名sorted_order，哪里就可以用cmp；

int (*tester)(int a, int b) = sorted_order;

• int (*tester)(int a, int b) = sorted_order;
• printf("TEST: %d ", tester(2,3)); 等价于printf("TEST: %d ", sorted_order(2,3));，此时，哪里可以用函数名sorted_order，哪里就可以用tester；

代码说明

• char *argv[] 本质是char **argv，因此是char **inputs = argv + 1;，这样，哪里可以用argv，哪里就可以用inputs，比如argv[0] = "ex18"; 等价于inputs[0] = "ex18"; ;

[习题13] for 循环 和 字符串数组 char *argv[]
https://www.jianshu.com/p/8773dc8df11c

• 使用int atoi( const char *str );把要进行排序的数值转换成int类型，number[i] = atoi(inputs[i]); ;

int atoi( const char *str );
https://en.cppreference.com/w/c/string/byte/atoi

附加任务

传入错误的函数类型

• 函数声明 void test_sorting(int *numbers, int count, compare_cb cmp) {}，第三个参数应该是compare_cb 类型

• 测试用例：各种错误函数类型做参数

test_sorting(numbers, count, test_sorting);
test_sorting(numbers, count, bubble_sort);
test_sorting(numbers, count, NULL);

• 编译器会提示，这是不匹配的参数类型incompatible pointer types
  这里输出'compare_cb' (aka 'int (*)(int, int)')
  结合代码typedef int(*compare_cb)(int a, int b);
  
  

  测试用例：各种错误函数类型做参数