A generic class member function for overloading - c++

Question

I was imagining a scenario, where I have a class which behaves as usual, but has some empty (member) function declared, which can be used (similar to overloading) as per needed. Is that possible? How can one achieve it?
To make myself clear, let's say I have a class which utilizes a given input function f at construction at some point (via the process member function below)
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
};
Now, what I can do is to specify the function f in the constructor for A and that will be utilized at the time of processing an instant of A. Using lambda function does this job. However, I wish f to be able to use As private members, as if it was part of As definition. Can it be done?
Thanks in advance,
Nikhil

Answer 1

Have f take reference to A as a parameter. Instead of f acessing A's private members, provide public getters and setters.
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

The basic technique is to make f accept parameters of the correct types (of A's private members) that it will be working on, and then pass those arguments to f inside the process() function. If there are many, then you'll want to break f up into smaller functions, and make process() call these smaller functions (and, of course, pass in the smaller functions in the constructor).

Answer 3

I'm not sure this is what you're after but I wrote a little example that might be along your lines. Make privatestuff a struct to store private variables in and you can send all the data in one go.
#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();
}