Initialize static function pointer in constructor - c++

Question

I am trying to declare a class-member function pointer as static so it can be called by a static member function, and assign the pointer to a function passed to the constructor.
So far I haven't been able to get it working, is this somehow possible?
#include <stdio.h>
//external callback function
static void innerFunc(int i, float f){
printf("running inner function : %i %f\n", i, f);
}
class A{
// member function pointer
typedef void (A::*cbPtr)(int, float);
static cbPtr cbptr;
public:
//constructor
A(void(*func)(int, float))
{
A::cbptr = func; // < this doesn't work
}
void run()
{
memberFunc(5, 4.4, NULL, NULL);
}
private:
// static member function
static void memberFunc(int i, float f, void* a, const void* aa)
{
printf("running outer function.\n");
// cbptr(i, f); // << I want to be able to call the function here
}
};
int main() {
A a(innerFunc);
a.run();
return 0;
}

Answer 1

The A::cbPtr type expects a pointer to a non-static member function of the A class. But you are trying to assign a pointer to a non-member function to your static cbptr variable. They are two different types, that is why the code does not compile.
Drop the A:: from your cbPtr typedef, eg:
#include <stdio.h>
//external callback function
static void innerFunc(int i, float f)
{
printf("running inner function : %i %f\n", i, f);
}
class A
{
public:
// non-member function pointer
typedef void (*cbPtr)(int, float);
//constructor
A(cbPtr func)
{
m_cbptr = func;
}
void run()
{
memberFunc(5, 4.4, NULL, NULL);
}
private:
static cbPtr m_cbptr;
// static member function
static void memberFunc(int i, float f, void* a, const void* aa)
{
printf("running outer function.\n");
m_cbptr(i, f);
}
};
A::cbPtr A::m_cbptr = NULL;
int main()
{
A a(innerFunc);
a.run();
return 0;
}
When you learn how to separate your declarations and definitions into .h and .cpp files, it would look more like this instead:
A.h:
#ifndef A_H
#define A_H
class A
{
public:
// non-member function pointer
typedef void (*cbPtr)(int, float);
//constructor
A(cbPtr func);
void run();
private:
static cbPtr m_cbptr;
// static member function
static void memberFunc(int i, float f, void* a, const void* aa);
};
#endif
A.cpp:
#include "A.h"
#include <stdio.h>
A::cbPtr A::m_cbptr = NULL;
A::A(A::cbPtr func)
{
m_cbptr = func;
}
void A::run()
{
memberFunc(5, 4.4, NULL, NULL);
}
void A::memberFunc(int i, float f, void* a, const void* aa)
{
printf("running outer function.\n");
m_cbptr(i, f);
}
main.cpp:
#include "A.h"
#include <stdio.h>
//external callback function
static void innerFunc(int i, float f)
{
printf("running inner function : %i %f\n", i, f);
}
int main()
{
A a(innerFunc);
a.run();
return 0;
}
Either way, just know that because m_cbptr is static, multiple instances of A will share the same variable, so you won't be able to have separate callbacks for different A objects. If memberFunc() were not static, or if its a or aa parameter is a user-defined value that can be set to point at the A object's this pointer, then you can have a separate callback per object.