Bamboozled by function pointers as arguments to another function within a class - c++

Question

I am bamboozled by function pointers.
Here is an example code:
#include <iostream>
class test
{
inline
void output_plumber_1(int* const arg_out, const int* const arg_in)
{
*arg_out = -*arg_in;
}
inline
void input_plumber_1(int* const arg_out, const int* const arg_in)
{
*arg_out = 2 * (*arg_in);
}
inline
void member_func(void (test::*output_plumber)(int* const arg_out, const int* const arg_in),
void (test::*input_plumber)(int* const arg_out, const int* const arg_in),
int arg)
{
int arg_copy;
(*input_plumber)(&arg_copy, &arg);
arg_copy = arg_copy + 1;
int arg_out;
(*output_plumber)(&arg_out, &arg_copy);
std::cout << arg_out << std::endl;
}
public:
void execute(int arg)
{
void (test::*output_plumber)(int* const arg_out, const int* const arg_in) = &test::output_plumber_1;
void (test::*input_plumber)(int* const arg_out, const int* const arg_in) = &test::input_plumber_1;
member_func(output_plumber, input_plumber, arg);
}
};
int main()
{
test mytest;
mytest.execute(1);
return 0;
}
What is it supposed to do?
This is a rather lean example, but essentially I have a program with a class with a member function which operates on some input data. Before performing the operation, and after performing the operation, the data must be fed into a set of input and output "plumber" functions which modify the data in preparation for "the operation" to take place, and "do something to it to correct for the initial preparation" after "the operation has taken place".
This sort of thing has arisen in my program as I am working with algorithms which operate on pairs of data (x, y) which only work when x > y. (Bizarre? But that's how it is.)
What is the problem?
Presumably numerous, however the immediate compiler output is the following:
main.cpp: In member function ‘void test::member_func(void (test::*)(int*, const int*), void (test::*)(int*, const int*), int)’:
main.cpp:27:11: error: invalid use of unary ‘*’ on pointer to member
(*input_plumber)(&arg_copy, &arg);
^
main.cpp:32:11: error: invalid use of unary ‘*’ on pointer to member
(*output_plumber)(&arg_out, &arg_copy);

Answer 1

This:
void (test::*output_plumber)(int* const arg_out, const int* const arg_in)
is a pointer to a member function of test, which takes two arguments and returns void. A pointer to member just points to a given member variable or function, but doesn't make any sense outside of the context of a class. So you can't call one without an instance.
The two allowed syntaxes are:
(obj.*ptr)(args...)
(p_obj->*ptr)(args...)
depending on whether or not the instance is a pointer. So the correct syntax to call your pointers would be:
(this->*input_plumber)(&arg_copy, &arg);
(this->*output_plumber)(&arg_out, &arg_copy);
And the correct way to call your function would be:
test_obj.member_func(&test::output_plumber_1, // <-- pointer to member
&test::input_plumber_1, // <-- pointer to member
0);

Answer 2

void (test::*input_plumber)(int* const arg_out, const int* const arg_in),
Based on your question, it appears that you believe that the above declares a parameter that's a function pointer.
Well, the above is not a function pointer. It's a class method pointer. It's not the same thing as a function pointer.
You cannot invoke input plumber as if it was a function pointer:
(*input_plumber)(&arg_copy, &arg);
You can't do it because this is a not a function pointer. Did I mention that this is not a function pointer, but a class method pointer? Yes, I think I did.
To invoke a method pointer, presuming that this is what you want to do, you must find an instance of a class whose method you wish to invoke, via the method pointer.
Asusming that you want to invoke this's method:
(this->*input_plumber)(&arg_copy, &arg);
Now, if you had some other pointer to test, lying around, for example:
test *some_ptr_to_test;
You would invoke that object's method pointer similarly:
(test->*input_plumber)(&arg_copy, &arg);