C++ C++；是否有一种已定义的方法来传递指向类的成员对象的成员函数的指针？_C++

C++ C++；是否有一种已定义的方法来传递指向类的成员对象的成员函数的指针？

c++

C++ C++；是否有一种已定义的方法来传递指向类的成员对象的成员函数的指针？,c++,C++,假设我有一些功能： void myFunction(void (MyClass::*function)(int), MyClass& myClass) { (myClass.*function)(1); } 其名称如下： class MyClass { int value; void setValue(int value) { this->value = value; } } MyClass myClass; myFunctio

假设我有一些功能：

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 MyClass {
    ChildClass childClass;
}

class ChildClass {
    int value;

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

< >在C++中，有一种方法将<代码> SETValue/Cuff>函数传递到<代码> MyFuffy>代码>，因为<代码> SETValue<代码>现在在<代码> ChildClass <代码>对象内<代码> MyClass < /C> > /P> 最明显的解决方案是将

setValue

成员函数添加到

MyClass

中，该函数在其

childClass

对象中调用

setValue

函数，如下所示：

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

之间的偏移量），但我当然想知道是否有更“内置”的实现这一点的方法。

这是否符合您的要求

class ChildClass {
public:
    int value;

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

class MyClass {
public:
    ChildClass childClass;
} ;

static void myFunction(void (ChildClass::*f)(int), MyClass& myClass) {
  (myClass.childClass.*f) (1) ;
}

int main() {
  MyClass myClass;
  myFunction(&ChildClass::setValue, myClass);
}

注意类定义后的分号。

这是否符合您的要求

class ChildClass {
public:
    int value;

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

class MyClass {
public:
    ChildClass childClass;
} ;

static void myFunction(void (ChildClass::*f)(int), MyClass& myClass) {
  (myClass.childClass.*f) (1) ;
}

int main() {
  MyClass myClass;
  myFunction(&ChildClass::setValue, myClass);
}

注意类定义后面的分号

是否有一种C++方式将SETValk函数传递到MyFalm中，因为现在MyClass中的ChildClass对象中的SET值是？有一种方法是添加一个间接级别。这种间接层次是多态函数包装器

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

可以在对象内部存储至少

sizeof（void（未定义的\u类：：*member\u指针）（）

，而无需分配堆内存。C++标准不需要这样做，但是，似乎优化的原因是使用<代码>：STD:：函数< /COD>成员函数指针比直接使用成员函数指针要糟糕得多。或者，换句话说，如果将代码中的成员和成员函数指针替换为

std:：function

，则应用程序不会因该†的额外内存分配而受到惩罚。在x86_64上使用

gcc

，这将在

std:：function

中产生16字节的内联存储，该内联存储可以存储具有2个对象引用的lambda捕获对象

†不过，

std:：function

的大小仍然大于此，而且它是一种非平凡类型，因此

myFunction