c++ - C++ 是否有定义的方法将指针传递给类的成员对象的成员函数？

Question

假设我有一些功能:

void myFunction(void (MyClass::*function)(int), MyClass& myClass) {
    (myClass.*function)(1);
}

调用如下:

class MyClass {
    int value;

    void setValue(int value) {
        this->value = value;
    }
}

MyClass myClass;
myFunction(&MyClass::set_value, myClass);

这个函数接受对象 myClass并说调用它的成员函数setValue ，它调用参数设置为 1。

在我意识到 C++ 支持将 成员 函数作为参数传递之前，我已经手动设置我的代码以接收对象和函数指针，然后确定它们地址之间的偏移量。如果给定相同类型对象的不同实例，则可以保存此偏移量以调用相同的成员函数。

但是，是的，然后我发现你可以做 Class::*function这(我假设)完全符合我之前构建/描述的内容。

这导致了我的问题，假设我有和以前一样的功能，只是我稍微改变了我的类结构:

class MyClass {
    ChildClass childClass;
}

class ChildClass {
    int value;

    void setValue(int value) {
        this->value = value;
    }
}

那么在 C++ 中有没有办法传递 setValue功能进入myFunction鉴于setValue现在在 ChildClass 内MyClass 内的对象？

最明显的解决方案是添加一个 setValue MyClass 的成员函数调用 setValue在其 childClass 中发挥作用对象，像这样:

class MyClass {
    ChildClass childClass;

    void setValue(int value) {
        this->childClass.setValue(value);
    }
}

class ChildClass {
    int value;

    void setValue(int value) {
        this->value = value;
    }
}

MyClass myClass;
myFunction(&MyClass::setValue, myClass);

但是，由于我正在处理的项目的语义，这不是一个理想的解决方案。因此，我很好奇是否有一种方法可以在 C++ 中实现这一点。如果没有，我当然可以手动实现它(它和以前一样，除了你会保存 childClass 成员和 MyClass 之间的偏移量以及 setValue 成员和 ChildClass 之间的偏移量。 )，但我很自然地想知道是否有更“内置”的方法来实现这一目标。

Answer 1

Is there then a way in C++ to pass the setValue function into myFunction given that setValue is now within the ChildClass object within MyClass?

有一种方法是添加一个间接级别。该间接级别是多态函数包装器 std::function . myFunction 可以接受一个 std::function 参数，它可以用任意访问器函数初始化，包括 labdas。例如:

#include <functional>

struct ChildClass {
    int value;

    void setValue(int value) {
        this->value = value;
    }
};

struct MyClass {
    ChildClass childClass;
};

void myFunction(std::function<void(MyClass&, int)> const& f, MyClass& myClass) {
    f(myClass, 1);
}

int main() {
    MyClass myClass;
    myFunction([](MyClass& a, int b) { a.childClass.setValue(b); }, myClass);
}

使用 std::function 你可以摆脱 MyClass& 参数并期望用户在 std::function 中提供所需的对象被 lambda 表达式捕获:

void myFunction2(std::function<void(int)> const& f) {
    f(1);
}

int main() {
    MyClass myClass;
    myFunction2([&myClass](int b) { myClass.childClass.setValue(b); });
}

请注意，std::function 可以在对象内部至少存储 sizeof(void(Undefined_class::*member_pointer)())) 而无需分配堆内存。 C++ 标准并不要求，但是，这种优化的原因似乎是使用 std::function 作为成员函数指针并不比直接使用成员函数指针差多少。或者，换句话说，如果您将代码中的成员和成员函数指针替换为 std::function，您的应用程序将不会因该^†。在 x86_64 上使用 gcc 会在 std::function 中产生 16 字节的内联存储，它可以存储具有 2 个对象引用的 lambda 捕获对象。

^† 不过，std::function 的大小仍然比那个大，而且它是一个非平凡的类型，所以 it cannot be passed or returned in registers .