是否可以交换 C 函数？

Question

想看看是否有人知道是否可以交换 C 函数...？

 void swap2(int(*a)(int), int(*b)(int)) {
   int(*temp)(int) = a;
   *a = *b;
   *b = temp;
   // Gives 'Non-object type 'int (int)' is not assignable
 }

 swap2(&funcA, &funcB);

编辑

这里有更多关于意图的数据——下面提供了一些答案做工作，例如使用typedef创建函数ptr，将它们指向函数并切换它们，这让你成功调用新交换的ptrs。

BUT 在交换后按其原始名称调用函数显示没有变化。本质上，我正在寻找 objc “swizzle”的 c 等价物。

我开始认为这是不可能的，因为 c 完全没有反射，并且需要实际修改二进制文件本身（显然不可行）。 D：

欢迎评论。

Answer 1

如果你使用下面这样的函数指针，是的

typedef int (*func_pt)(int);

func_pt a, b;

void swap(func_pt * a, func_pt * b)
{
    func_pt tmp = *b;
    *b = *a;
    *a = tmp;
}

swap(&a, &b);

或者你这样用，我觉得不是：

int test1(int a)
{
    return a;
}

int test2(int b)
{
    return b;
}

swap(&test1, &test2);

完整的编译工作程序

#include <stdio.h>
#include <stdlib.h>

typedef int (* func_pt)(int);

func_pt a, b;

int test1(int a)
{
    printf("test1\n");
    return 1;
}

int test2(int a)
{
    printf("test2\n");
    return 2;
}

void swap(func_pt * a, func_pt * b)
{
    func_pt tmp = *b;

    *b = *a;
    *a = tmp;
}

int main(void)
{
    a = &test1;
    b = &test2;

    printf("before\n");
    a(1);
    b(1);

    swap(&a, &b);

    printf("after\n");
    a(1);
    b(2);

    return 0;

}

输出：

before
test1
test2
after
test2
test1

有些人自己不去尝试，就说很荒唐。所以我给你举个例子。

Answer 2

我很确定您需要指向函数指针的指针来交换指针，不是吗？这种类型的交换函数交换值；你真的想处理地址。示例函数调用不会真正起作用，因为 C 不将函数视为一等变量，因此您实际上不能直接交换函数；您需要使用指向函数地址的指针，因为地址可以交换：

void swap2(int(**a)(int), int(**b)(int)) {
   int(*temp)(int) = *a;
   *a = *b;
   *b = *temp;
}

int(*func1)(int) = &foo;
int(*func2)(int) = &bar;

swap2(&func1, &func2);

Answer 3

您的代码在赋值时会出现“invalid lvalue”之类的错误。正如我在您的代码中看到的那样，您正在尝试在不更改其值的情况下交换指针，因此请查看以下解决方案。

void swap2(int(**a)(int), int(**b)(int)) {   
   int(*temp)(int) = *a;
   *a = *b;
   *b = temp;
}

int main(){
    int(*temp1)(int) = &funcA;
    int(*temp2)(int) = &funcB;
    swap2(&temp1,&temp2);
}

Answer 4

是的，你可以。认为函数指针只是一个内存地址，唯一的要求是：保存此类地址的位置必须是可变的。说，int (*foo)() 并不是真正指向 foo 指向的位置。可能是printf() 或fopen()。

Answer 5

虽然主题询问交换功能，但您实际上想模仿swizzle 所做的事情。这只是意味着您希望能够调用相同的函数名称，但让它做一些不同的事情。

只有指针的解决方案不会给你这种行为。如果这对您来说不重要，那么您应该采用仅提供的函数指针解决方案之一。如果它对您很重要，那么您将需要引入一个抽象层。抽象可以在底层使用函数指针（尽管还有其他解决方案）。

此接口用户的 API 将是：

/* API to initialize */
void abstract_func_init ();

/* API to manipulate abstract functions */
typedef int abstract_func_type ();
abstract_func_type * abstract_func_get (abstract_func_type *key);
int abstract_func_set (abstract_func_type *key, abstract_func_type *behavior);

/* the abstract functions */
extern int foo ();
extern int bar ();

这样一个接口的实现可能如下所示：

static void insert (abstract_func_type *key, abstract_func_type **behavior)
{ /* associate key to behavior */ }
static abstract_func_type ** lookup (abstract_func_type *key)
{ /* return behavior from key */ }

abstract_func_type * abstract_func_get (abstract_func_type *k) {
    abstract_func_type **f = lookup(k);
    if (f) return *f;
    return 0;
}

int abstract_func_set (abstract_func_type *k, abstract_func_type *p) {
    abstract_func_type **f = lookup(k);
    if (f) {
        *f = p;
        return 0;
    }
    return -ENOENT;
}

#define DEFINE_ABSTRACT_FUNC(func) \
    static int static_##func (); \
    static abstract_func_type *func##_ptr = static_##func; \
    int func () { return func##_ptr(); } \
    static int static_##func ()

DEFINE_ABSTRACT_FUNC(foo) { return puts("foo"); }
DEFINE_ABSTRACT_FUNC(bar) { return puts("bar"); }

void abstract_func_init () {
    insert(foo, &foo_ptr);
    insert(bar, &bar_ptr);
}

那么，您最初在帖子中提出的swap() 可以这样实现：

void swap (abstract_func_type *a, abstract_func_type *b) {
    abstract_func_type *ap = abstract_func_get(a);
    abstract_func_type *bp = abstract_func_get(b);
    abstract_func_set(a, bp);
    abstract_func_set(b, ap);
}

这是一个调用swap()的程序：

    puts("before swap");
    foo();
    bar();
    swap(foo, bar);
    puts("after swap");
    foo();
    bar();

它的输出是：

before swap
foo
bar
after swap
bar
foo

要自动将抽象函数添加到查找表中，您可以在构建系统中引入一个额外的步骤，该步骤调用一个脚本，该脚本将 grep 从 DEFINE_ABSTRACT_FUNC 行中取出，并生成一个新的源文件，该文件具有对每个这样的行调用insert() 的函数。

完整版的模型可以在here找到。