在c和c++中实现函数回调

在C和C++中实现函数回调，需要用到函数指针；函数指针是将函数的入口地址存放在指针变量中，可以通过指针来间接调用函数。

以下是实现函数回调的步骤：

1. 声明一个函数指针类型，以便后续能实现复用：

   c++
typedef void(*CallbackFunction)(int);

   上面的代码定义了一个函数指针类型CallbackFunction，该函数指针可以指向一个返回类型为void，带有一个int类型参数的函数。

2. 定义需要回调的函数：

   c++
void process(CallbackFunction callback){
for(int i=0;i<10;i++){
callback(i);
}
}

   上面的代码定义了一个process函数，该函数接受一个函数指针callback作为参数并执行10次，每次执行都会调用该函数指针。

3. 在回调函数的实现函数中，调用需要回调的函数并传入回调函数指针：

   ```c++
   void callback(int num){
   std::cout << "num = " << num << std::endl;
   }

   process(callback); //将callback函数的入口地址传给process函数
   ```

   上面代码中，定义了一个回调函数callback，该函数接受一个int类型参数并输出该参数的值。在调用process函数时，将函数指针callback作为参数传递给process函数。

下面是两个更加具体的示例：

• 示例一：使用函数回调实现字符串数组排序

#include<iostream>
#include<string>

typedef bool(*CompareFunction)(std::string, std::string);

bool ascending(std::string x, std::string y){
    return x < y;
}

bool descending(std::string x, std::string y){
    return x > y;
}

void sort(std::string* arr, int len, CompareFunction compare){
    for(int i=0;i<len;i++){
        for(int j=i+1;j<len;j++){
            if(compare(arr[j],arr[i])){
                std::swap(arr[i],arr[j]);
            }
        }
    }
}

int main(){
    std::string arr[] = {"Z", "A", "E", "B", "D", "C"};
    int len = sizeof(arr) / sizeof(std::string);

    sort(arr, len, ascending); //使用ascending函数进行排序
    for(int i=0;i<len;i++){
        std::cout << arr[i] << " ";
    }

    std::cout << std::endl;

    sort(arr, len, descending); //使用descending函数进行排序
    for(int i=0;i<len;i++){
        std::cout << arr[i] << " ";
    }

    std::cout << std::endl;

    return 0;
}

在上面的例子中，定义了一个函数指针类型CompareFunction，该函数指针可以指向一个返回类型为bool，带有两个std::string类型参数的函数。sort函数将需要排序的数组、数组长度和函数指针作为参数传入。程序中使用ascending函数和descending函数作为回调函数，来决定从小到大或者从大到小排序。

• 示例二：使用函数回调实现多线程

#include<iostream>
#include<thread>

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

void process(ThreadFunction callback, int start, int end){
    std::thread t(callback, start, end);
    t.join();
}

void add(int start, int end){
    int sum = 0;
    for(int i=start;i<=end;i++){
        sum += i;
    }
    std::cout << "sum of [" << start << ", " << end << "] = " << sum << std::endl;
}

void multiply(int start, int end){
    int result = 1;
    for(int i=start;i<=end;i++){
        result *= i;
    }
    std::cout << "product of [" << start << ", " << end << "] = " << result << std::endl;
}

int main(){
    process(add, 1, 100); //在新线程中执行add函数
    process(multiply, 1, 10); //在新线程中执行multiply函数
    return 0;
}

在上面的例子中，定义了一个函数指针类型ThreadFunction，该函数指针可以指向一个返回类型为void，带有两个int类型参数的函数。process函数将需要执行的函数、第一个int类型参数和第二个int类型参数作为参数传入，并在新的线程中执行。程序中使用add函数和multiply函数作为回调函数，来在新的线程中执行加法与乘法。