c - 如何将参数传递给 C 中的函数指针？

Question

在下面的代码片段中Reference , compare 是从 main() 调用的，没有传递任何参数。我假设它以 ((char *)&key, (char *)string) 作为函数调用所需的两个参数。但是它在 C 内部是如何工作的呢？调用compare时编译器是否填充参数？

#include <search.h>
#include <string.h>
#include <stdio.h>

#define  CNT           2

int compare(const void *arg1,const void *arg2)
{
   return (strncmp(*(char **)arg1, *(char **)arg2, strlen(*(char **)arg1)));
}

int main(void)
{
   char **result;
   char *key = "PATH";
   unsigned int num = CNT;
   char *string[CNT] =  {
      "PATH = d:\\david\\matthew\\heather\\ed\\simon","LIB = PATH\\abc" };

   /* The following statement finds the argument that starts with "PATH"         */

   if ((result = (char **)lfind((char *)&key, (char *)string, &num,
                  sizeof(char *), compare)) != NULL)
      printf("%s found\n", *result);
   else
      printf("PATH not found \n");
   return 0;


}

How do function pointers in C work?

Answer 1

compare is called from main() without any parameters being passed.

没有。它只是从 main 中引用。

本质上，它告诉 lfind“嘿，如果你想比较条目，使用这个函数——它可以完全按照你期望的方式调用。”

lfind，然后，知道这一点，并且每当它需要比较两个条目时，它会将参数放在正常调用中会放置它们的任何地方(在堆栈上、正确的寄存器中或任何地方) ，取决于体系结构的调用约定)并执行对给定地址的调用。这称为间接调用，通常比直接调用要贵一些。

让我们切换到一个更简单的例子:

#include <stdio.h>

int add1(int x) {
    return x + 1;
}

int times2(int x) {
    return x * 2;
}

int indirect42(int(*f)(int)) {
    // Call the function we are passed with 42 and return the result.
    return f(42);
}

int indirect0(int(*f)(int)) {
    // Call the function we are passed with 0 and return the result.
    return f(0);
}

int main() {
    printf("%d\n", add1(33));
    printf("%d\n", indirect42(add1));
    printf("%d\n", indirect0(add1));

    printf("%d\n", times2(33));
    printf("%d\n", indirect42(times2));
    printf("%d\n", indirect0(times2));
    return 0;
}

在这里，我首先自己调用函数 add1()，然后我告诉另外两个函数根据自己的目的使用该函数。然后我用另一个函数做同样的事情。

这完美地工作 - 我用 33 调用这两个函数，然后用 42 和 0 调用。结果 - 第一个函数为 34、43 和 1，第二个函数为 66、84 和 0 - 符合预期.

如果我们看一下 x86 汇编器输出，我们会看到

…
indirect42:
.LFB13:
    .cfi_startproc
    movl    4(%esp), %eax
    movl    $42, 4(%esp)
    jmp *%eax
    .cfi_endproc

该函数将给定的函数指针获取到 %eax，然后将 42 放在预期的位置，然后调用 %eax。 (相应地，当我激活优化时，它跳到那里。逻辑保持不变。)

函数不知道要调用哪个函数，而是如何调用它。

indirect0:
.LFB14:
    .cfi_startproc
    movl    4(%esp), %eax
    movl    $0, 4(%esp)
    jmp *%eax
    .cfi_endproc

该函数与另一个函数的作用相同，但它将 0 传递给它获得的任何函数。

然后，在调用所有这些东西时，我们得到

    movl    $33, (%esp)
    call    add1
    movl    %eax, 4(%esp)
    movl    $.LC0, (%esp)
    call    printf

这里我们有一个正常的函数调用。

    movl    $add1, (%esp)
    call    indirect42
    movl    %eax, 4(%esp)
    movl    $.LC0, (%esp)
    call    printf

在这里，add1 的地址被压入堆栈并提供给 indirect42，以便该函数可以按需要处理它。

    movl    $add1, (%esp)
    call    indirect0
    movl    %eax, 4(%esp)
    movl    $.LC0, (%esp)
    call    printf

与indirect0相同。

(其他东西剪掉了，因为它的工作原理相同)