我最喜欢的函数指针用途之一是迭代器-

#include <stdio.h>
#define MAX_COLORS  256

typedef struct {
    char* name;
    int red;
    int green;
    int blue;
} Color;

Color Colors[MAX_COLORS];


void eachColor (void (*fp)(Color *c)) {
    int i;
    for (i=0; i<MAX_COLORS; i++)
        (*fp)(&Colors[i]);
}

void printColor(Color* c) {
    if (c->name)
        printf("%s = %i,%i,%i\n", c->name, c->red, c->green, c->blue);
}

int main() {
    Colors[0].name="red";
    Colors[0].red=255;
    Colors[1].name="blue";
    Colors[1].blue=255;
    Colors[2].name="black";

    eachColor(printColor);
}

由于函数指针通常是类型化回调，因此您可能需要查看类型安全回调。这同样适用于非回调函数的入口点等。

C相当善变，同时也很宽容：）

函数指针的另一个好用法：在版本之间轻松切换

当您需要在不同的时间或不同的开发阶段使用不同的功能时，它们非常方便。例如，我正在一台有控制台的主机上开发一个应用程序，但该软件的最终版本将放在Avnet ZedBoard（它有显示器和控制台的端口，但最终版本不需要这些端口）上。所以在开发过程中，我将使用printf查看状态和错误消息，但当我完成后，我不希望打印任何内容。以下是我所做的：

版本.h

// First, undefine all macros associated with version.h
#undef DEBUG_VERSION
#undef RELEASE_VERSION
#undef INVALID_VERSION


// Define which version we want to use
#define DEBUG_VERSION       // The current version
// #define RELEASE_VERSION  // To be uncommented when finished debugging

#ifndef __VERSION_H_      /* prevent circular inclusions */
    #define __VERSION_H_  /* by using protection macros */
    void board_init();
    void noprintf(const char *c, ...); // mimic the printf prototype
#endif

// Mimics the printf function prototype. This is what I'll actually 
// use to print stuff to the screen
void (* zprintf)(const char*, ...); 

// If debug version, use printf
#ifdef DEBUG_VERSION
    #include <stdio.h>
#endif

// If both debug and release version, error
#ifdef DEBUG_VERSION
#ifdef RELEASE_VERSION
    #define INVALID_VERSION
#endif
#endif

// If neither debug or release version, error
#ifndef DEBUG_VERSION
#ifndef RELEASE_VERSION
    #define INVALID_VERSION
#endif
#endif

#ifdef INVALID_VERSION
    // Won't allow compilation without a valid version define
    #error "Invalid version definition"
#endif

在版本c中，我将定义版本h中的2个函数原型

版本.c

#include "version.h"

/*****************************************************************************/
/**
* @name board_init
*
* Sets up the application based on the version type defined in version.h.
* Includes allowing or prohibiting printing to STDOUT.
*
* MUST BE CALLED FIRST THING IN MAIN
*
* @return    None
*
*****************************************************************************/
void board_init()
{
    // Assign the print function to the correct function pointer
    #ifdef DEBUG_VERSION
        zprintf = &printf;
    #else
        // Defined below this function
        zprintf = &noprintf;
    #endif
}

/*****************************************************************************/
/**
* @name noprintf
*
* simply returns with no actions performed
*
* @return   None
*
*****************************************************************************/
void noprintf(const char* c, ...)
{
    return;
}

注意函数指针在版本.h中如何原型化为void（*zprintf）（constchar*，…）；当它在应用程序中被引用时，它将在其指向的任何位置开始执行，这一点尚未定义。在版本.c中，注意在board_init（）函数中，zprintf被分配了一个唯一的函数（其函数签名匹配），这取决于版本中定义的版本

运行代码将如下所示：

主程序c

#include "version.h"
#include <stdlib.h>
int main()
{
    // Must run board_init(), which assigns the function
    // pointer to an actual function
    board_init();

    void *ptr = malloc(100); // Allocate 100 bytes of memory
    // malloc returns NULL if unable to allocate the memory.

    if (ptr == NULL)
    {
        zprintf("Unable to allocate memory\n");
        return 1;
    }

    // Other things to do...
    return 0;
}

如果处于调试模式，上述代码将使用printf，如果处于发布模式，则不执行任何操作。这比浏览整个项目并注释或删除代码要容易得多。我所需要做的就是在版本.h中更改版本，其余的都由代码完成！

C中函数指针的一个主要用途是调用在运行时选择的函数。例如，C运行时库有两个例程，qsort和bsearch，它们获取一个指向函数的指针，该函数被调用来比较正在排序的两个项目；这允许您根据希望使用的任何条件分别对任何内容进行排序或搜索。

一个非常基本的例子是，如果有一个名为print（int x，int y）的函数，反过来可能需要调用一个函数（add（）或sub（），它们是相同类型的），那么我们将做什么，我们将向print（）函数添加一个函数指针参数，如下所示：

#include <stdio.h>

int add()
{
   return (100+10);
}

int sub()
{
   return (100-10);
}

void print(int x, int y, int (*func)())
{
    printf("value is: %d\n", (x+y+(*func)()));
}

int main()
{
    int x=100, y=200;
    print(x,y,add);
    print(x,y,sub);

    return 0;
}

输出为：

值为：410值为：390

我最喜欢的函数指针用途之一是迭代器-

#include <stdio.h>
#define MAX_COLORS  256

typedef struct {
    char* name;
    int red;
    int green;
    int blue;
} Color;

Color Colors[MAX_COLORS];


void eachColor (void (*fp)(Color *c)) {
    int i;
    for (i=0; i<MAX_COLORS; i++)
        (*fp)(&Colors[i]);
}

void printColor(Color* c) {
    if (c->name)
        printf("%s = %i,%i,%i\n", c->name, c->red, c->green, c->blue);
}

int main() {
    Colors[0].name="red";
    Colors[0].red=255;
    Colors[1].name="blue";
    Colors[1].blue=255;
    Colors[2].name="black";

    eachColor(printColor);
}

被解雇的指南：如何在x86机器上通过手工编译代码滥用GCC中的函数指针：

这些字符串文字是32位x86机器代码的字节。0xC3是x86 ret指令。

你通常不会用手工编写这些，你会用汇编语言编写，然后使用像nasm这样的汇编程序将其汇编成一个平面二进制，然后将其十六进制转储成一个C字符串文字。

返回EAX寄存器上的当前值int eax=（（int（*）（））（“\xc3<-返回eax寄存器的值”）（）；编写交换函数整数a=10，b=20；（（void（*）（int*，int*））“\x8b\x44\x04\x8b\x5c\x24\x08\x80\x80\x8b\ux1b\x31\x31\xc3\xcb\x4c\x24\x04\x09\x01\xcb\x4c\x04\x08\x49\xc3<-这将交换a和b的值”）（-a，-b）；将for循环计数器写入1000，每次调用一些函数（（int（*）（））“\x66\x31\xc0\x8b\x5c\x24\x64\x66\x40\x50\xxf\xd3\x58\x66\x3d\xC8\x03\x75\xf4\xc3”）（函数）；//调用函数1->1000您甚至可以编写一个计数为100的递归函数const char*lol=“\x8b\x5c\x24\x4\x3\x8\x3\x0\x0\x7e\x2\x31\x80\x83\x48\x64\x7d\x6\x40\x53\xdf\xd3\x5b\xc3\xc3<-递归调用地址lol处的函数。”；i=（（int（*）（））（lol））（lol）；

请注意，编译器将字符串文本放在.rodata部分（或Windows上的.rata），该部分作为文本段的一部分链接（以及函数代码）。

文本段具有Read+Exec权限，因此将字符串文本转换为函数指针是有效的，而无需像动态分配内存那样进行mprotect（）或VirtualProtect（）系统调用。（或者gcc-z execstack将程序与堆栈+数据段+堆可执行文件链接起来，作为快速破解。）

要反汇编这些，您可以编译它以在字节上添加标签，并使用反汇编程序。

// at global scope
const char swap[] = "\x8b\x44\x24\x04\x8b\x5c\x24\x08\x8b\x00\x8b\x1b\x31\xc3\x31\xd8\x31\xc3\x8b\x4c\x24\x04\x89\x01\x8b\x4c\x24\x08\x89\x19\xc3 <- This swaps the values of a and b";

用gcc-c-m32-foo.c编译，用objdump-D-rwC-Mintel反汇编，我们可以得到程序集，并发现该代码通过破坏EBX（一个调用保留寄存器）而违反了ABI，通常效率很低。

00000000 <swap>:
   0:   8b 44 24 04             mov    eax,DWORD PTR [esp+0x4]   # load int *a arg from the stack
   4:   8b 5c 24 08             mov    ebx,DWORD PTR [esp+0x8]   # ebx = b
   8:   8b 00                   mov    eax,DWORD PTR [eax]       # dereference: eax = *a
   a:   8b 1b                   mov    ebx,DWORD PTR [ebx]
   c:   31 c3                   xor    ebx,eax                # pointless xor-swap
   e:   31 d8                   xor    eax,ebx                # instead of just storing with opposite registers
  10:   31 c3                   xor    ebx,eax
  12:   8b 4c 24 04             mov    ecx,DWORD PTR [esp+0x4]  # reload a from the stack
  16:   89 01                   mov    DWORD PTR [ecx],eax     # store to *a
  18:   8b 4c 24 08             mov    ecx,DWORD PTR [esp+0x8]
  1c:   89 19                   mov    DWORD PTR [ecx],ebx
  1e:   c3                      ret    

  not shown: the later bytes are ASCII text documentation
  they're not executed by the CPU because the ret instruction sends execution back to the caller

在Windows、Linux、OS X等系统上，这段机器代码（可能）可以在32位代码中工作：所有这些OS上的默认调用约定都在堆栈中传递参数，而不是在寄存器中更有效地传递参数。但EBX在所有正常的调用约定中都保留了调用，因此将其用作临时寄存器而不保存/恢复它很容易使调用者崩溃。