将非静态成员函数传递给另一个类的成员函数

class A {
public:
    void func() {
        // 非静态成员函数
    }
};

class B {
public:
    using FuncPtr = void (A::*)(); // 定义函数指针类型

    void setCallback(FuncPtr callback) {
        callback_ = callback;
    }

    void invokeCallback() {
        A a;
        (a.*callback_)(); // 通过函数指针调用A的成员函数
    }

private:
    FuncPtr callback_;
};

int main() {
    A a;
    B b;
    b.setCallback(&A::func); // 将A的成员函数地址赋值给函数指针
    b.invokeCallback(); // 调用B的成员函数，间接调用A的成员函数
    return 0;
}

class A {
public:
    void operator()() {
        // 非静态成员函数
    }
};

class B {
public:
    void setCallback(A callback) {
        callback_ = callback;
    }

    void invokeCallback() {
        callback_(); // 直接调用函数对象的operator()，间接调用A的成员函数
    }

private:
    A callback_;
};

int main() {
    A a;
    B b;
    b.setCallback(a); // 将A的函数对象作为参数传递给B的成员函数
    b.invokeCallback(); // 调用B的成员函数，间接调用A的成员函数
    return 0;
}

class A {
public:
    void func() {
        // 非静态成员函数
    }
};

class B {
public:
    void setCallback(std::function<void()> callback) {
        callback_ = callback;
    }

    void invokeCallback() {
        callback_(); // 直接调用Lambda表达式，间接调用A的成员函数
    }

private:
    std::function<void()> callback_;
};

int main() {
    A a;
    B b;
    b.setCallback([&a]() { a.func(); }); // 将A的成员函数封装为Lambda表达式，并作为参数传递给B的成员函数
    b.invokeCallback(); // 调用B的成员函数，间接调用A的成员函数
    return 0;
}