What does this code mean?

Quote:

Original post by KWest But can someone give me some examples of situations where a variable of this type might be used.

Function pointers are used for callback functions. For example, in my game engine, I use callbacks to communicate between the engine and the actual game code. Whenever the engine recieves a network message, or a physics event such as a collision occurs, the engine calls a callback function to the game code so that the game can deal with the collision/net message however it sees fit. By supplying my engine a function pointer, my engine never needs to know about any of the actual game code, and can stay nice and modular.

Quote:

Are there any other ways of achieving the same results, if so what are the pros and cons of those alternatives?

You could use a function object.

Quote:

Original post by Anonymous Poster defines mFunctionpointer as a pointer to a function that returns void and takes a void * as argument.

This is close, but not quite. It's actually declaring mFunctionpointer as a function pointer TYPE that you can use to instantiate function pointers that return void and take a void* instance:

// Make an instance of a function pointermFunctionpointer myFunctionPtr; // A void function..void Foo(void*){    // do something}// Assign the void function to the function pointermyFunctionPtr = Foo;// Now you could call the function like this..void* pBar;myFunctionPtr(pBar);

A pure virtual class/Interface class is another nice way of achieving the same result, though one could argue in certain situation where performance is critical, the cost of calling a virtual function would be a sufficient reason for not doing that.

Examples:

typedef void (*PrintCallback)(const char*);class MyClass{public:    void PrintName() { pPrinterCallback(szName) };private:    printCallback pPrinterCallback;    char* szName;}

Without funtion pointer one could use

class Printer{public:    virtual void Print(const char* _szString) = 0;}class MyClass{public:    void PrintName() { pPrinter->Print(szName) };private:    Printer* pPrinter;    char* szName;}

Of course the second method would require you to define a class that inheritates form Printer and which actually defines what its Print method does.
In my opinion, the nice point with that method is that when it comes to do more elaborated stuff, you are not limited to just one function, you can build a full class and organize everything in a nice object oriented way.

For instance, that would be possible:

class MyClass: public Printer{public:    MyClass() { pPrinter = this; }    void PrintName() { pPrinter->Print(szName) };private:    void Print(const char* _szString) { std::cout << szName << std::endl; }    Printer* pPrinter;    char* szName;}

The java's implementation of listeners inspired me that.
It might not be perfect though, I'd like to know what do other people think.

Quote:

Original post by janta A pure virtual class/Interface class is another nice way of achieving the same result,

It's not quite the same. The virtual call is not reassignable at run-time. Of course, the same function pointer can't target both member functions and statics, which is why I like to use Fast Delegates for all my virtual indirection.

What do you mean ?

You can have:

class AnImplementationOfPrinter: public Printer { ... }
class AnotherImplementationOfPrinter : public Printer { ... }

then set the "pPrinter" to any instance of those classes at run time.

Didi I miss your point ?

Listener classes could also be used instead of functors.