函数指针是包含函数地址的变量。由于它是一个指针变量，但是具有某些受限制的属性，因此您可以像使用数据结构中的任何其他指针变量一样使用它。
我能想到的唯一例外是将函数指针视为指向单个值以外的其他东西。通过递增或递减函数指针或对函数指针增加/减去偏移量来进行指针算术并不是真正的实用程序，因为函数指针仅指向单个对象，即函数的入口点。
函数指针变量的大小，该变量占用的字节数可能会根据基础架构（例如x32或x64或其他）而有所不同。
函数指针变量的声明需要指定与函数声明相同的信息，以便C编译器执行通常执行的检查。如果在函数指针的声明/定义中未指定参数列表，则C编译器将无法检查参数的使用。在某些情况下，缺乏检查很有用，但是请记住，安全网已被移除。
一些例子：
int func (int a, char *pStr); // declares a function
int (*pFunc)(int a, char *pStr); // declares or defines a function pointer
int (*pFunc2) (); // declares or defines a function pointer, no parameter list specified.
int (*pFunc3) (void); // declares or defines a function pointer, no arguments.
前两个声明的相似之处在于：
func是一个接受a int和a char *并返回an 的函数intpFunc是一个函数指针，分配给该函数的函数的地址是a int和a char *并返回aint
因此从上面我们可以得到一个源代码行，其中函数的地址func()被分配给函数指针变量，pFunc如中所示pFunc = func;。
注意函数指针声明/定义所使用的语法，其中括号被用来克服自然的运算符优先级规则。
int *pfunc(int a, char *pStr); // declares a function that returns int pointer
int (*pFunc)(int a, char *pStr); // declares a function pointer that returns an int
几种不同的用法示例
使用函数指针的一些示例：
int (*pFunc) (int a, char *pStr); // declare a simple function pointer variable
int (*pFunc[55])(int a, char *pStr); // declare an array of 55 function pointers
int (**pFunc)(int a, char *pStr); // declare a pointer to a function pointer variable
struct { // declare a struct that contains a function pointer
int x22;
int (*pFunc)(int a, char *pStr);
} thing = {0, func}; // assign values to the struct variable
char * xF (int x, int (*p)(int a, char *pStr)); // declare a function that has a function pointer as an argument
char * (*pxF) (int x, int (*p)(int a, char *pStr)); // declare a function pointer that points to a function that has a function pointer as an argument
您可以在函数指针的定义中使用可变长度参数列表。
int sum (int a, int b, ...);
int (*psum)(int a, int b, ...);
或根本无法指定参数列表。这可能很有用，但是它消除了C编译器对提供的参数列表执行检查的机会。
int sum (); // nothing specified in the argument list so could be anything or nothing
int (*psum)();
int sum2(void); // void specified in the argument list so no parameters when calling this function
int (*psum2)(void);
C风格演员表
您可以将C样式强制转换与函数指针一起使用。但是请注意，C编译器可能对检查比较松懈，或者提供警告而不是错误。
int sum (int a, char *b);
int (*psplsum) (int a, int b);
psplsum = sum; // generates a compiler warning
psplsum = (int (*)(int a, int b)) sum; // no compiler warning, cast to function pointer
psplsum = (int *(int a, int b)) sum; // compiler error of bad cast generated, parenthesis are required.
比较功能指针与相等性
您可以使用一条if语句来检查函数指针是否等于特定函数地址，尽管我不确定这样做是否有用。其他比较运算符的效用似乎更低。
static int func1(int a, int b) {
return a + b;
}
static int func2(int a, int b, char *c) {
return c[0] + a + b;
}
static int func3(int a, int b, char *x) {
return a + b;
}
static char *func4(int a, int b, char *c, int (*p)())
{
if (p == func1) {
p(a, b);
}
else if (p == func2) {
p(a, b, c); // warning C4047: '==': 'int (__cdecl *)()' differs in levels of indirection from 'char *(__cdecl *)(int,int,char *)'
} else if (p == func3) {
p(a, b, c);
}
return c;
}
函数指针数组
而且，如果您要有一个函数指针数组，每个参数列表中的元素都不同，那么您可以定义一个函数指针，其中未指定参数列表（void这并不意味着没有参数，只是未指定），如下所示：可能会从C编译器看到警告。这也适用于函数的函数指针参数：
int(*p[])() = { // an array of function pointers
func1, func2, func3
};
int(**pp)(); // a pointer to a function pointer
p[0](a, b);
p[1](a, b, 0);
p[2](a, b); // oops, left off the last argument but it compiles anyway.
func4(a, b, 0, func1);
func4(a, b, 0, func2); // warning C4047: 'function': 'int (__cdecl *)()' differs in levels of indirection from 'char *(__cdecl *)(int,int,char *)'
func4(a, b, 0, func3);
// iterate over the array elements using an array index
for (i = 0; i < sizeof(p) / sizeof(p[0]); i++) {
func4(a, b, 0, p[i]);
}
// iterate over the array elements using a pointer
for (pp = p; pp < p + sizeof(p)/sizeof(p[0]); pp++) {
(*pp)(a, b, 0); // pointer to a function pointer so must dereference it.
func4(a, b, 0, *pp); // pointer to a function pointer so must dereference it.
}
C样式与函数指针一起namespace使用Globalstruct
您可以使用static关键字指定名称为文件作用域的函数，然后将其分配给全局变量，以提供类似于namespaceC ++功能的方式。
在头文件中定义一个结构，它将成为我们的命名空间以及使用它的全局变量。
typedef struct {
int (*func1) (int a, int b); // pointer to function that returns an int
char *(*func2) (int a, int b, char *c); // pointer to function that returns a pointer
} FuncThings;
extern const FuncThings FuncThingsGlobal;
然后在C源文件中：
#include "header.h"
// the function names used with these static functions do not need to be the
// same as the struct member names. It's just helpful if they are when trying
// to search for them.
// the static keyword ensures these names are file scope only and not visible
// outside of the file.
static int func1 (int a, int b)
{
return a + b;
}
static char *func2 (int a, int b, char *c)
{
c[0] = a % 100; c[1] = b % 50;
return c;
}
const FuncThings FuncThingsGlobal = {func1, func2};
然后，通过指定全局struct变量的完整名称和成员名称来使用该名称，以访问该函数。该const改性剂的全球化，所以它不能被意外的改变。
int abcd = FuncThingsGlobal.func1 (a, b);
功能指针的应用领域
DLL库组件可以执行与C样式namespace方法类似的操作，在C 方法中，从支持创建struct包含函数指针的库接口中的工厂方法中请求特定的库接口。此库接口加载所请求的DLL版本，具有必要函数指针的结构，然后将该结构返回给发出请求的调用方以供使用。
typedef struct {
HMODULE hModule;
int (*Func1)();
int (*Func2)();
int(*Func3)(int a, int b);
} LibraryFuncStruct;
int LoadLibraryFunc LPCTSTR dllFileName, LibraryFuncStruct *pStruct)
{
int retStatus = 0; // default is an error detected
pStruct->hModule = LoadLibrary (dllFileName);
if (pStruct->hModule) {
pStruct->Func1 = (int (*)()) GetProcAddress (pStruct->hModule, "Func1");
pStruct->Func2 = (int (*)()) GetProcAddress (pStruct->hModule, "Func2");
pStruct->Func3 = (int (*)(int a, int b)) GetProcAddress(pStruct->hModule, "Func3");
retStatus = 1;
}
return retStatus;
}
void FreeLibraryFunc (LibraryFuncStruct *pStruct)
{
if (pStruct->hModule) FreeLibrary (pStruct->hModule);
pStruct->hModule = 0;
}
这可以用于：
LibraryFuncStruct myLib = {0};
LoadLibraryFunc (L"library.dll", &myLib);
// ....
myLib.Func1();
// ....
FreeLibraryFunc (&myLib);
可以使用相同的方法为使用底层硬件的特定模型的代码定义抽象硬件层。工厂用功能特定的函数填充功能指针，以提供实现特定抽象硬件模型中指定功能的功能。这可以用来提供由软件使用的抽象硬件层，该软件调用工厂函数以获取特定的硬件功能接口，然后使用提供的功能指针对基础硬件执行操作，而无需了解有关特定目标的实现细节。
用于创建委托，处理程序和回调的函数指针
您可以使用函数指针来委派某些任务或功能。在C中的典型的例子是与标准C库函数使用的比较委托函数指针qsort()和bsearch()用于排序的项目的列表或执行过的项目的排序列表二进制搜索提供归类顺序。比较函数委托指定排序或二进制搜索中使用的排序规则算法。
另一个用途类似于将算法应用于C ++标准模板库容器。
void * ApplyAlgorithm (void *pArray, size_t sizeItem, size_t nItems, int (*p)(void *)) {
unsigned char *pList = pArray;
unsigned char *pListEnd = pList + nItems * sizeItem;
for ( ; pList < pListEnd; pList += sizeItem) {
p (pList);
}
return pArray;
}
int pIncrement(int *pI) {
(*pI)++;
return 1;
}
void * ApplyFold(void *pArray, size_t sizeItem, size_t nItems, void * pResult, int(*p)(void *, void *)) {
unsigned char *pList = pArray;
unsigned char *pListEnd = pList + nItems * sizeItem;
for (; pList < pListEnd; pList += sizeItem) {
p(pList, pResult);
}
return pArray;
}
int pSummation(int *pI, int *pSum) {
(*pSum) += *pI;
return 1;
}
// source code and then lets use our function.
int intList[30] = { 0 }, iSum = 0;
ApplyAlgorithm(intList, sizeof(int), sizeof(intList) / sizeof(intList[0]), pIncrement);
ApplyFold(intList, sizeof(int), sizeof(intList) / sizeof(intList[0]), &iSum, pSummation);
另一个示例是GUI源代码，其中通过提供一个函数指针来注册特定事件的处理程序，该函数指针在事件发生时实际被调用。Microsoft MFC框架及其消息映射使用类似的方法来处理传递到窗口或线程的Windows消息。
需要回调的异步函数类似于事件处理程序。异步函数的用户调用异步函数以启动某些操作，并提供一个函数指针，一旦操作完成，异步函数将调用该函数指针。在这种情况下，事件是异步功能完成其任务。
之后，让我们看一下机器如何理解它们。上述程序在32位架构中的机器指令一览。