Question

我正在想象一个场景，我有一个像往常一样的行，但是声明了一些空（成员）函数，可以根据需要使用（类似于重载）。那可能吗？怎么能实现呢？

为了使自己清楚，假设我有一个类在某个时刻在构造中使用给定的输入函数f（通过下面的process成员函数）

 class A {
    // constructor
    A(const Graph& g, 
      std::function<void(void*)> f = [](void*){  } ) {
    ...        
    }

    // member functions
    ...       

private:
    // member variables
    ...        
    // private member functions
    void process(void);               // This function will utilize the input function f   
};

现在，我可以做的是在f的构造函数中指定函数A，并在处理A的瞬间时使用该函数。使用lambda函数可以完成这项工作。但是，我希望f能够使用A个私有成员，就像它是A定义的一部分一样。可以吗？

提前致谢， NIKHIL

Answer 1

让f作为参数引用A。不是f访问A的私人成员，而是提供公共吸气者和制定者。

class A {
public:
    A (const Graph& g, std::function <void (void*, A&)> f)
        : f_(f)
    {}

     // getters and setters

private:

     std::function<void (void*, A&)> f_;

     void process () {
         f_(nullptr, *this);
     }
};

Answer 2

基本技术是使f接受正在处理的正确类型（A的私有成员）的参数，然后将这些参数传递给process（）函数中的f。如果有很多，那么你需要将f分解为更小的函数，并使process（）调用这些较小的函数（当然，传入构造函数中较小的函数）。

Answer 3

我不确定这是你所追求的，但是我写了一个可能符合您要求的小例子。使privatestuff成为存储私有变量的结构，您可以一次性发送所有数据。

#include <functional>
#include <iostream>

using namespace std;

typedef std::function<void(void*)> DoStuffFunc;

class A
{
public:
    A(DoStuffFunc func) {
        doStuff = func;
        privateStuff = 5;
    }
    void process() {
        doStuff((void*)&privateStuff);
    }
private:
    int privateStuff;
    DoStuffFunc doStuff;
};

void doStuffX(void* data) {
    int x = *(int*)data;
    cout <<"x: " <<x <<endl;
}

int main(int argc, char** argv) {
    DoStuffFunc fX = doStuffX;
    A ax(fX);
    ax.process();
}

用于重载的泛型类成员函数

3 个答案: