Thread: Function-pointer scope problem.

Like this?

Code:

class Widget;

typedef long (*EventCallback)(Widget*,int);

class Widget {
  EventCallback	func;
};

The first class is just a forward declaration for the class. It's all you need to create a pointer to it, since there is no need to work out the size simply to have a pointer to it.

Think of it as a function prototype. That's pretty much all it is, except it's for an object.


Quzah.

Actually, in the case of function prototypes, it's bad practice to leave them out.

So long as you only use them where necessary (in which case, you have no choice), there shouldn't be a problem.
You only need them where you have some sort of mutual recursion going on like this example, that you need a forward declaration just to break the cycle.

Actually, forward declarations can be very good in many cases; they can help to greatly reduce compile time.

For example, say you have this:

Code:

// B.h
#include "A.h"

class B{
   public:
      ...
   private:
      A* theA;
};

You'd be better off removing #include "A.h", and replacing it with "class A;". You then move the #include "A.h" into B.cpp instead of B.h.

The reason for this is to improve compile time. If you make a change to A.h and you are using the first scenario, every cpp file that includes A.h OR B.h needs to be recompiled. If you use the second way, only files that directly include A.h need recompilation.

It's quite possible on large projects with many, many .cpp and .h files, that a single change in a .h file could force a full recompile on every single source file, and typically those large projects are the ones with the 20 minute or longer compile times.

In general, the best practice is to only use a full #include when you cannot get away with just a forward declaration. Especially when the file you're including may change; it's not such a big deal with things like <string> or <iostream> where you can be quite sure they're not changing.

If you're interested, you can check out this URL, and look at the example. Note that even though class A uses a C* within the class, neither the header file nor the .cpp file actually require a full definition of class C, and so c.h is never included in either.