如何将带有回调参数的系统调用包装到 C++ 类中？

Question

我想将 Linux 系统调用 API（克隆）包装到 C++ 类中。

但是，这个API需要一个函数指针，而且它的参数列表是固定的，例如：

typedef int (*callback)(void *);
void system_call(callback f) {
    void *t = nullptr;
    f(t);
}

现在，我的班级如下：

class Foo {
public:
    void start() {
        // WRONG: cannot pass non-static member function due to pointer `this`
        system_call(this->foo);
    }
private:
    int foo(void *args) {
        f->necessary();
        return 0;
    }
    void necessary() {
        std::cout << "call success!!!" << std::endl;
    }
};

int main() {
    Foo obj;
    obj.start();
}

所以，重要的问题是：

1. system_call 的参数是固定不变的。
2. 方法start() 必须是非静态的。

我正在考虑这个，通过使用静态成员：

class Foo {
public:
    void start() {
        auto func = std::bind(foo, std::placeholders::_1, this);
        system_call(func);  // WRONG: cannot convert std::_Bind to a function pointer
    }
private:
    static int foo(void *args, Foo *f) {
        f->necessary();
        return 0;
    }
    void necessary() {
        std::cout << "call success!!!" << std::endl;
    }
};

或者这个，通过使用带有捕获的 lambda：

class Foo {
public:
    void start() {
        auto func = [this](void *args) -> int {
            this->necessary();
        };
        system_call(func); // WRONG: cannot convert a lambda with captures to a function pointer
    }
private:
    void necessary() {
        std::cout << "call success!!!" << std::endl;
    }
};

他们都错了。

有解决这个问题的方法吗？

附：我认为这是对封装的巨大要求，但是在这里我发现一些答案并不优雅（他们修改了参数列表，无法用于系统调用）：

how to pass a non static-member function as a callback?

Answer 1

我知道这是一个 XY 问题。我专门问了哪个系统调用有问题，你写的是clone()。

如果你review the documentation of clone()你会发现它需要一个arg参数，还有：

当fn(arg)函数应用返回时，子进程 终止。 fn 返回的整数是退出代码 子进程。子进程也可能终止 通过调用 exit(2) 或在收到致命信号后显式调用。

因此，只需将静态 callback() 函数传递给 clone()。

然后将this 指针传递给arg。

然后让你的callback() 调用真正的类方法。

void callback(void *arg)
{
    reinterpret_cast<Foo *>(arg)->foo();
}

不仅如此，使用单指针传递任意参数也很简单：

1. 定义一个struct，除了指向要调用其方法的Foo 类的指针之外，它还包含任何需要的参数。

2. new类的实例，将this放入指针中，初始化要传递的参数。

3. 将指向此类的指针作为arg 参数传递给clone()。

1234563 .

这是一种非常常见的设计模式：一个接受回调函数指针的函数还将接受一个额外的第二个不透明指针，该指针被转发到回调函数，它可以使用它来存储回调所需的任何辅助数据.例如指向应调用其方法的类的实例的指针。不以这种方式构建回调机制实际上是一种糟糕的编程习惯。

Answer 2

解决方案 1

最简单的解决方法是使用使用全局变量的非成员函数。

// The global variable
Foo* currentFooPtr = NULL;

// The callback function. Define it after the definition of Foo
int foo_callback(void *);

然后在设置currentFooPtr的值后使用foo_callback作为system_call的参数。

class Foo {
public:
    void start() {
        currentFooPtr = this;
        system_call(foo_callback);
    }
};

int foo_callback(void *)
{
   // Use currentFooPtr any way you wish to
}

多线程程序的重要说明（感谢@SamVarshavchik）：

这只有在应用程序不是多线程的情况下才有效；或者，具体来说，不能同时执行多次系统调用。否则，您可能希望调用受全局互斥体保护。

解决方案 2

使用static 成员变量和static 成员函数代替全局变量和非成员函数。我认为它比解决方案 1 更好，因为它不会将变量或函数添加到仅供 Foo 使用的全局范围内。

class Foo {
public:
    void start() {
        currentFooPtr = this;
        system_call(foo_callback);
    }

    static Foo* currentFooPtr;
    static int foo_callback(void*);      
};

Foo* Foo::currentFooPtr = NULL;

int Foo::foo_callback(void *)
{
   // Use currentFooPtr any way you wish to
}