Why should I use the static method for using this callback? - c++

Question

I'm trying to implement Marmalade's IwBilling (c++) but all is what I get is the error: "Reference to non-static member function must be called".
I use the following code:
=== [ main cpp file ] ===
#include <s3e.h>
#include "MyGame.h"
int main () {
IwGxInit();
{
MyGame game = new MyGame();
}
IwGxTerminate();
}
=== [ MyGame.h ] ===
#include "IwBilling.h"
class MyGame{
void billingError( void* caller, IwBilling::CIwBillingErrorData* data ) {}
MyGame() {
if ( IwBilling::isAvailable() && IwBilling::Init() ) {
IwBilling::setErrorCallback( billingError ); // !!! ERROR: Reference to non-static member function must be called
}
}
};
What's the problem here? Why do this works like this? If I write: "static void billingError" all works fine. But I don't know if that correct to use static before void billingError?
I don't understand why my MyGame() constructor is a static method? How can I do it non-static?

Answer 1

In C++, nonstatic member functions are always associated with an instance of the class that they are declared within. Thus in order to call them, you have to have an instance of that class available. So if billingError() is declared nonstatic, you would have to call it with an instance of MyGame like this:
MyGame* myGame = new MyGame();
myGame->billingError(); // myGame is the instance for this call
Static functions can be called without an instance of the class like so:
MyGame::billingError(); // assuming billingError() was declared static
The reason for this distinction is nonstatic member functions have an implicit 'this' pointer passed to them, which is a pointer to the instance that the function is called on (myGame in the first example would be the 'this' pointer inside of that function). The 'this' pointer is passed as an invisible parameter to the function. Static functions on the other hand don't have any extra implicit parameters.
Because the two types of functions have different calling conventions, pointers to them are treated differently. So if you wanted to use a nonstatic billingError() function, you would have to declare setErrorCallback() to take a nonstatic function pointer and pass an instance of MyGame. For example:
class IwBilling {
void setErrorCallback( void (MyGame::*callback) (void* caller, IwBilling::CIwBillingErrorData* data), MyGame* instance ) {
// do some stuff
instance->callback(caller, data);
}
}
On the other hand, if you don't need an instance of myGame, then you can declare billingError() static, and declare the setErrorCallback() callback parameter as a static function pointer like this:
class IwBilling {
void setErrorCallback( void (*callback) (void* caller, IwBilling::CIwBillingErrorData* data) ) {
// do some stuff
callback(caller, data);
}
}

Answer 2

Unfortunately, IwBilling callbacks do not follow the usual pattern of passing along a user-defined void* which you could use to indicate which instance of your class to invoke the method upon. So you are probably stuck with some static ugliness like this:
class MyGame{
static MyGame* instance; // define and initialize this in your .cpp file
void billingError( void* caller, IwBilling::CIwBillingErrorData* data ) {}
static void billingErrorStatic( void* caller, IwBilling::CIwBillingErrorData* data ) {
instance->billingError(caller, data); // call the non-static method
}
MyGame() {
if ( IwBilling::isAvailable() && IwBilling::Init() ) {
IwBilling::setErrorCallback( &MyGame::billingErrorStatic );
}
}
};