示例代码
假设有一个简单的函数和一个指向它的函数指针：
#include <iostream>
// 定义一个简单的函数
int add(int a, int b) {
return a + b;
}
int main() {
// 定义一个指向函数的指针
int (*funcPtr)(int, int) = add;
// 直接使用函数指针调用函数
int result1 = funcPtr(2, 3);
std::cout << "Result 1: " << result1 << std::endl;
// 解引用函数指针后调用函数
int result2 = (*funcPtr)(2, 3);
std::cout << "Result 2: " << result2 << std::endl;
return 0;
}

输出结果
上述代码运行后，会产生以下输出：
Result 1: 5
Result 2: 5

解释
直接使用函数指针调用 (funcPtr(2, 3))：
编译器会自动将 funcPtr 解释为指向函数的指针，并调用该函数。
解引用函数指针后调用 ((*funcPtr)(2, 3))：
这里明确地将 funcPtr 进行解引用，然后调用指向的函数。虽然显式地解引用函数指针，但效果和直接调用是一样的。
为什么它们是等价的？
在 C++ 中，函数指针和函数名的使用在某些方面是相似的。函数指针本质上是指向函数的地址，在调用时，编译器会自动处理指针的解引用，以便执行指针指向的函数。这使得两种调用方式在语义上是等价的。

在 C++ 中，函数指针数组是一种可以存储多个函数指针的数组。为了使用这些函数指针，需要对其元素进行解引用，才能调用指向的函数。下面是详细的解释和例子。

函数指针数组的定义与使用定义函数指针数组
假设有一个返回 int 并接收 int 参数的函数类型，你可以这样定义一个函数指针数组：
int func1(int a) {
return a + 1;
}
int func2(int a) {
return a * 2;
}
int (*funcPtrArray[])(int) = {func1, func2};
在这个例子中，funcPtrArray 是一个函数指针数组，它包含了两个函数指针，分别指向 func1 和 func2。

调用函数指针数组中的函数
为了调用函数指针数组中的函数，需要对数组元素进行解引用。可以通过下标访问元素，然后进行解引用调用函数：
#include <iostream>
int main() {
int result1 = funcPtrArray ; // 等价于 (*funcPtrArray[0])(5)
int result2 = funcPtrArray ; // 等价于 (*funcPtrArray[1])(5)
std::cout << "Result 1: " << result1 << std::endl; // 输出 6
std::cout << "Result 2: " << result2 << std::endl; // 输出 10
return 0;
}
这里直接使用 funcPtrArray 和 funcPtrArray 来调用函数，这实际上是对函数指针进行了解引用并调用它们。

更复杂的例子
如果函数签名更复杂，例如返回 void 并接收两个 int 参数的函数，可以这样定义和使用：
#include <iostream>
void func1(int a, int b) {
std::cout << "Sum: " << a + b << std::endl;
}
void func2(int a, int b) {
std::cout << "Product: " << a * b << std::endl;
}
void (*funcPtrArray[])(int, int) = {func1, func2};
int main() {
funcPtrArray[0](3, 4); // 调用 func1(3, 4)
funcPtrArray[1](3, 4); // 调用 func2(3, 4)
return 0;
}

解引用的必要性
正如上面的例子所示，调用函数指针数组中的函数时，实际上是对函数指针进行了解引用。C++ 允许简化的调用语法，因此可以直接使用 funcPtrArray[i](args)，而不必显式写作 (*funcPtrArray[i])(args)。不过，两者在效果上是等价的。

总结
函数指针数组用于存储多个函数指针。
调用函数指针数组中的函数需要对其元素进行解引用，调用语法可以简化为 funcPtrArray[i](args)。
使用函数指针数组可以灵活管理和调用多个函数，特别是在处理类似回调函数的情境中非常有用。
通过正确使用函数指针数组，可以在 C++ 中实现灵活且高效的函数调用机制

函数指针数组的定义和使用
定义函数指针数组
假设有两个简单的函数：
int func1(int a) {
return a + 1;
}
int func2(int a) {
return a * 2;
}

我们可以定义一个函数指针数组，用于存储这些函数的指针：
int (*funcPtrArray[])(int) = {func1, func2};
在这个数组中，funcPtrArray[0] 指向 func1，funcPtrArray[1] 指向 func2。

调用函数指针数组中的函数
为了调用函数指针数组中的函数，可以直接使用函数指针数组的元素，或者显式地对函数指针进行解引用。
#include <iostream>
int func1(int a) {
return a + 1;
}
int func2(int a) {
return a * 2;
}
int main() {
// 定义一个函数指针数组
int (*funcPtrArray[])(int) = {func1, func2};
// 调用数组中的第一个函数
int result1 = funcPtrArray ; // 直接调用
int result2 = (*funcPtrArray[0])(5); // 显式解引用后调用
std::cout << "Result 1: " << result1 << std::endl; // 输出 6
std::cout << "Result 2: " << result2 << std::endl; // 输出 6
// 调用数组中的第二个函数
int result3 = funcPtrArray ; // 直接调用
int result4 = (*funcPtrArray[1])(5); // 显式解引用后调用
std::cout << "Result 3: " << result3 << std::endl; // 输出 10
std::cout << "Result 4: " << result4 << std::endl; // 输出 10
return 0;
}

解释
直接使用函数指针调用 (funcPtrArray )：
funcPtrArray[0] 是一个函数指针，直接调用 funcPtrArray[0](5) 会调用 func1(5)。
解引用函数指针后调用 ((*funcPtrArray[0])(5))：
(*funcPtrArray[0]) 解引用了函数指针，然后再调用该函数，效果和直接调用是一样的，即 func1(5)。
调用数组中的第二个函数：
funcPtrArray 和 (*funcPtrArray[1])(5) 都是调用 func2(5)，效果相同。

关键点
函数指针数组：定义一个数组，用于存储多个函数指针。
调用方式：可以直接使用函数指针调用函数，也可以显式地解引用后再调用，两种方式效果等价。