C++ Function Pointer as Argument and Classes? - c++

Question

Hmm I'm reading some guides on this but I can't figure this out, how do I properly use function pointers in C++?
I have a class that I want to call a function after it has finished whatever it is doing at the moment, like this:
class WindowImages
{
public:
void Update()
{
for(unsigned int i = 0; i < _images.size(); i++)
{
//Do something
_images[i]->MyFunctionPointer();
}
}
void Add(Image* image, void (*func)(void))
{
image->function = func; //this is wrong
_images.push_back(image);
}
private:
vector<Image*> _images;
}
class Image
{
public:
void ImageClicked();
void *function(void);
};
void main()
{
Image* image = new Image();
WindowImages images;
images.Add(image, image->ImageClicked);
}
I'm trying to add the image to the vector, and pass a function as argument that will be called when the images class finish doing whatever it has to do with each image.
The functions will be different per image but they'll all be in the void function() format.
I've been trying a bunch of things but got nothing so far, how can I do this?
Also, if you happen to have a more... beginner friendly tutorial or guide on function pointers (and even maybe C++ 11 lambdas) that'd be really helpful!

Answer 1

You're not using a regular function pointer for your callback. You're using a non-static member function pointer, so the regular function pointer syntax and calling mechanics aren't going to work. There is a significant difference both in the pointer declaration syntax and the mechanism used for invoking non-static members.
To declare a pointer-to-member function for a member of the Image class taking no parameters and returning void, the syntax would be:
void (Image::*function)().
Invoking a member function is done using one of two special operators, ->* when using an object pointer, or .* when using an object reference. For example:
// declare a pointer to Image member function
void (Image::*function)();
// assign address of member function
function = &Image::ImageClicked;
// uses ->* for access
Image *pObj = new Image();
(pObj->*function)();
// uses .* for access
Image image;
(image.*function)();
Hope that helps

Answer 2

First of all, I think your intention is better done via C++ polymorphism, though which is done by function pointer underhood. C++ function pointer tutorial
The following code does what you want to do.
#include <iostream>
#include <vector>
#include <cmath>
using namespace std;
void f1() {
cout << "f1()" << endl;
}
void f2() {
cout << "f2()" << endl;
}
void f3() {
cout << "f3()" << endl;
}
class A {
public:
void (*fp)();
};
class B {
public:
void add(A* a, void (*fp)()) {
a->fp = fp;
vec_a.push_back(a);
}
~B() {
for (int i = 0; i < vec_a.size(); ++i) {
vec_a[i]->fp();
}
}
private:
vector<A*> vec_a;
};
int main() {
B *b = new B();
A* a[3];
a[0] = new A();
a[1] = new A();
a[2] = new A();
b->add(a[0], f1);
b->add(a[1], f2);
b->add(a[2], f3);
delete b;
}
The output is
f1()
f2()
f3()

Answer 3

First and foremost, I suggest against using function pointers in C++. In general, the same functionality can and should be achieved using virtual classes.
When working with function pointers, I find typedefs to be really useful to keep things organized. This somewhat contrived example accomplishes roughly what you are trying to do...
#include <stdio.h>
#include <vector>
typedef void (*fptr_type) (int);
void printSquare (int i) {
printf ("%d\n", i * i);
return;
}
void printDouble (int i) {
printf ("%d\n", 2 * i);
return;
}
class IntFPtrClass {
public:
int intVal;
fptr_type fptr;
IntFPtrClass (int i, fptr_type f) : intVal(i), fptr(f) { }
// Just to show that static methods can be used as function pointers.
static void printPlusOne(int i) {
printf ("%d\n", i + 1);
return;
}
};
int main (void)
{
std::vector<IntFPtrClass> my_vector;
my_vector.push_back (IntFPtrClass(3, printSquare));
my_vector.push_back (IntFPtrClass(5, printDouble));
my_vector.push_back (IntFPtrClass(7, IntFPtrClass::printPlusOne));
for (int i = 0; i < my_vector.size(); ++i)
{
my_vector[i].fptr(my_vector[i].intVal);
}
return 0;
}