C++ 我可以使用C++；函数指针，如C#'；什么行动？

在C++中，我第一次遇到函数指针。
我试图用它来让它类似于C#中的动作和委托。
但是，在声明函数指针时，必须指定函数所在类的类型。
无效（A:：*F）（）
我可以使用可以存储任何类的成员函数的函数指针吗

通常，函数指针的使用如下面的代码所示

class A {
public:
    void AF() { cout << "A::F" << endl; }
};

class B {
public:
    void(A::*BF)();
};

int main()
{
    A a;
    B b;

    b.BF = &A::AF;
    (a.*b.BF)();

    return 0;
}

A类{
公众：
void AF（）

#include <functional>
#include <iostream>

class A {
public:
    void AF() { std::cout << "A::F" << std::endl; }
};

class B {
public:
    B(const std::function<void()>& bf) : BF(bf) {}
    std::function<void()> BF;
};

int main() {
    A a;
    B b1(std::bind(&A::AF, &a)); // using std::bind
    B b2([&a] { a.AF(); });      // using a lambda

    b1.BF();
    b2.BF();

    return 0;
}

#包括
#包括
甲级{
公众：
void AF（）{std:：cout这是一个C#风格的可接受答案的实现，它是内存高效且灵活的，因为您可以在不同的执行点构造和委托，而C#开发人员可能希望这样做：

#include <iostream>
#include <functional>

using namespace std;

class A {
public:
    void AF() { cout << "A::F" << endl; }
    void BF() { cout << "B::F" << endl; }
};

class B {
public:
    std::function<void()> Delegate;
};

int main() {
    A a;
    B b;

    b.Delegate = std::bind(&A::AF, &a);
    b.Delegate();

    b.Delegate = [&a] { a.BF(); };
    b.Delegate();
    return 0;
}

#包括
#包括
使用名称空间std；
甲级{
公众：
无论如何，你不能只让<代码> AF < /> >静态方法还是全局函数？无论如何，你不必访问类<代码> < < /代码>。我不能用代码读取答案，但是你可以从我这里读到这个答案，从C++读取关于AutoType AANSTD:：变量的代码。17@Drock“阅读有关自动类型的信息”-
auto
不是一个类型。它只是一个关键字，告诉编译器在初始化变量时推断出正确的类型本身。变量仍然有一个静态类型，并且该类型不能更改。例如；
int i=42；
和
auto i=42；
的结果完全相同。在这两种情况下，
i
的样式都是相同的>是
int
，它将永远保持
int
。@Drock只是出于兴趣，为什么它值得阅读变量？你可以使用模板
std:：function
作为成员函数指针。模板类型不需要类。
std:：bind
是一个古老的学派。我会选择基于lamda的答案。好吧，对于lambda，n我认为它不再回答这个问题了，因为用
函数
捕获lambda和在lambda中调用方法都很简单，也没有什么特别的。@snak也比
绑定
更有效，因为生成的对象更小，实际上不需要在
std:：function
中分配内存我从来没有使用过lambda表达式，所以我做了一些搜索并理解了。谢谢！@snak
b2（[&a]{a.AF（）；}）
，正如Ted已经编辑过的，当他决定向委托函数添加任何参数时，100%地回答了这个问题，并避免了操作人员的头痛。从技术上讲，这更有效。由于构造函数中的
常量和
，接受的答案将被迫复制初始化成员
std:：function
。在您的情况下，它将通过哦，好的。我也有点新的C++。我会相应地改变。我的意思是你不需要改变任何东西。上面的文字：我对C语言风格很熟悉，这是一个很好的答案。
#include <functional>
#include <iostream>

class A {
public:
    void AF() { std::cout << "A::F" << std::endl; }
};

class B {
public:
    B(const std::function<void()>& bf) : BF(bf) {}
    std::function<void()> BF;
};

int main() {
    A a;
    B b1(std::bind(&A::AF, &a)); // using std::bind
    B b2([&a] { a.AF(); });      // using a lambda

    b1.BF();
    b2.BF();

    return 0;
}

#include <iostream>
#include <functional>

using namespace std;

class A {
public:
    void AF() { cout << "A::F" << endl; }
    void BF() { cout << "B::F" << endl; }
};

class B {
public:
    std::function<void()> Delegate;
};

int main() {
    A a;
    B b;

    b.Delegate = std::bind(&A::AF, &a);
    b.Delegate();

    b.Delegate = [&a] { a.BF(); };
    b.Delegate();
    return 0;
}