类似 C 的回调处理：哪种算法执行速度更快？

Question

我有一系列像这样的回调 void (*callbacks[n])(void* sender) 我想知道其中哪一个代码执行速度更快：

//Method A
void nullcallback(void* sender){};

void callbacka(void* sender) 
{
    printf("Hello ");
}

void callbackb(void* sender)
{
    printf("world\n");
}

int main()
{
    void (*callbacks[5])(void* sender);
    unsigned i;
    for (i=0;i<5;++i)
        callbacks[i] = nullcallback;
    callbacks[2] = callbacka;
    callbacks[4] = callbackb;
    for (i=0;i<5;++i)
        callbacks[i](NULL);
};

或

//Method B
void callbacka(void* sender) 
{
    printf("Hello ");
}

void callbackb(void* sender)
{
    printf("world\n");
}

int main()
{
    void (*callbacks[5])(void* sender);
    unsigned i;
    for (i=0;i<5;++i)
        callbacks[i] = NULL;
    callbacks[2] = callbacka;
    callbacks[4] = callbackb;
    for (i=0;i<5;++i)
        if (callbacks[i])
            callbacks[i](NULL);
};

某些条件：

• 这很重要我是否知道我的大部分回调是否有效？
• 如果我使用 C 或 C++ 编译器编译代码，会有什么不同吗？
• 目标平台（Windows、Linux、Mac、iOS、Android）是否会改变结果？ （这个回调数组的全部目的是为了管理游戏中的回调）

Answer 1

您必须为此查看汇编代码。在我的平台（gcc，32 位）上，我发现编译器无法优化对 nullcallback 的调用。但是，如果我将您的方法 A 改进为以下内容，

int main(void) {
  static void (*const callbacks[5])(void* sender) = {
    [0] = nullcallback,
    [1] = nullcallback,
    [2] = callbacka,
    [3] = nullcallback,
    [4] = callbackb,
  };
  for (unsigned i=0;i<5;++i)
        callbacks[i](0);
};

编译器就能够展开循环并优化调用，结果就是

    .type   main, @function
main:
    pushl   %ebp
    movl    %esp, %ebp
    andl    $-16, %esp
    subl    $16, %esp
    movl    $0, (%esp)
    call    callbacka
    movl    $0, (%esp)
    call    callbackb
    xorl    %eax, %eax
    leave
    ret
    .size   main, .-main

Answer 2

这完全取决于你的实际情况。如果可能的话，我更喜欢方法 A，因为它更容易阅读和生成更清晰的代码，特别是如果您的函数有返回值：

ret = callbacks[UPDATE_EVENT](sender);
// is nicer then
if (callbacks[UPDATE_EVENT])
    ret = callbacks[UPDATE_EVENT](sender);
else
    ret = 0;

当然，当您不仅有一个函数签名，而且有 100 个不同的签名时，方法 A 就会变得 tedouis 。对于每个你都必须编写一个空函数。

出于性能考虑，这取决于 nullcallback() 是否是罕见情况。如果很少见，方法A显然更快。如果不是，方法 B 可能会稍微快一些，但这取决于很多因素：您使用哪个平台，您的函数有多少参数等。但无论如何，如果您的回调正在做“真正的工作”，即。不仅仅是一些简单的计算，根本不重要。

当您不仅为一个发送者调用回调，而且为许多发送者调用回调时，您的方法 B 确实可以更快：

extern void *senders[SENDERS_COUNT]; // SENDERS_COUNT is a large number

if (callbacks[UPDATE_EVENT])
{
    for (int i = 0; i < SENDERS_COUNT; i++)
        callbacks[UPDATE_EVENT](senders[i]);
} 

这里，当没有有效的回调时，将跳过整个循环。如果 nullcallback() 地址已知，也可以使用方法 A 来完成此调整，即仅在某些模块中未定义。

Answer 3

您可以通过简单地对数组进行零初始化来进一步优化您的代码，如下所示：

void (*callbacks[5])(void* sender) = { 0 };

然后您就完全消除了 for 循环将每个指针设置为 NULL 的需要。您现在只需为 callbacka 和 callbackb 进行分配。

Answer 4

对于一般情况，方法 B 是首选，但对于函数指针 LUT（当 NULL 为例外时）比方法 A 微观上更快。

主要示例是 Linux 系统调用表，NULL 调用只应在运行在较新系统上构建的二进制文件或程序员错误的极少数情况下发生。系统调用发生的频率足够高，以至于纳秒甚至皮秒的改进可以有所帮助。

其他可能证明它有价值的实例是仿真器（例如 MAME）内的操作码 LUT。