C语言使用函数指针数组

使用函数指针数组是C语言中一种非常灵活的编程技巧，可以在代码中实现更加复杂的逻辑，提高代码的可读性和可维护性。本文将详细讲解如何使用函数指针数组，包含以下几个方面的内容：

函数指针数组的定义和初始化
函数指针数组的使用方法
示例演示

函数指针数组的定义和初始化

函数指针数组是由多个函数指针组成的数组，其定义形式为：

returnType (*arrayName[ArraySize])(parameterList);

例如，定义一个包含3个函数指针的函数指针数组，每个函数指针指向的函数原型如下：

int func1(int a, int b);
float func2(float x, float y, float z);
double func3(double m, double n);

则可以定义如下的函数指针数组：

int (*funcArray[3])(int, int) = {func1, func1, func1};
float (*funcArray2[3])(float, float, float) = {func2, func2, func2};
double (*funcArray3[3])(double, double) = {func3, func3, func3};

这里的(*funcArray)表示函数指针数组的名称，[3]表示数组的大小，(int, int)表示函数的参数类型，{func1, func1, func1}表示函数指针数组的初始化值，这里分别使用func1初始化了数组的所有元素，也可以使用不同的函数指针进行初始化。

函数指针数组的使用方法

定义好函数指针数组后，可以通过函数指针数组访问和调用数组中的函数。

访问函数指针数组中的元素，可以使用下标运算符（[]），例如：

int result = (*funcArray[0])(1, 2);

这里的funcArray[0]表示函数指针数组的第一个元素，由于是函数指针，所以需要使用(*funcArray[0])进行间接访问其指向的函数。接着，传递参数1, 2，调用了func1函数并返回其返回值。

调用函数指针数组中的函数，可以直接使用函数名进行调用，例如：

int result = funcArray[0](1, 2);

这里的funcArray[0]表示函数指针数组的第一个元素，直接使用其函数名funcArray[0]进行调用，并传递参数1, 2，调用了func1函数并返回其返回值。

示例演示

下面通过两个示例演示函数指针数组的使用。

示例1：最大值函数

定义一个函数指针数组，其中包含3个指向函数的指针，每个函数的功能是求两个数中的最大值。

#include <stdio.h>

int max(int a, int b) {
    return a > b ? a : b;
}

float max2(float x, float y, float z) {
    float temp = x > y ? x : y;
    return temp > z ? temp : z;
}

double max3(double m, double n) {
    return m > n ? m : n;
}

int main() {
    int (*maxFunc[3])(int, int) = {max, max, max};
    float (*maxFunc2[3])(float, float, float) = {max2, max2, max2};
    double (*maxFunc3[3])(double, double) = {max3, max3, max3};

    int a = 5, b = 6;
    float x = 3.14, y = 2.314, z = 4.523;
    double m = 4.534, n = 6.443;

    int result = (*maxFunc[0])(a, b);
    printf("result=%d\n", result);

    float result2 = maxFunc2[0](x, y, z);
    printf("result2=%f\n", result2);

    double result3 = (*maxFunc3[0])(m, n);
    printf("result3=%lf\n", result3);

    return 0;
}

输出结果为：

result=6
result2=4.523000
result3=6.443000

示例2：数组排序函数

定义一个函数指针数组，其中包含两个指向函数的指针，用于对整数数组进行排序，一个函数使用冒泡排序，一个函数使用快速排序。

#include <stdio.h>

void bubbleSort(int arr[], int n) {
    int i, j;
    for (i = 0; i < n - 1; i++) {
        for (j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

void quickSort(int arr[], int left, int right) {
    if (left >= right) {
        return;
    }

    int i = left;
    int j = right;
    int pivot = arr[(left + right) / 2];

    while (i <= j) {
        while (arr[i] < pivot) {
            i++;
        }

        while (arr[j] > pivot) {
            j--;
        }

        if (i <= j) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            i++;
            j--;
        }
    }

    quickSort(arr, left, j);
    quickSort(arr, i, right);
}

void sortArray(int arr[], int n, void (*sortFunc[2])(int[], int)) {
    (*sortFunc[0])(arr, n);
    // (*sortFunc[1])(arr, 0, n - 1);
}

int main() {
    void (*sortFunc[2])(int[], int) = {bubbleSort, quickSort};

    int arr[] = {23, 45, 12, 34, 56, 8, 88, 11, 90, 41};
    int n = sizeof(arr) / sizeof(arr[0]);
    sortArray(arr, n, sortFunc);

    int i;
    for (i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}