CODEWITHSUNDEEP
c++classforward-declaration
MTVS
MTVS

Reputation: 2096

class forward declaration

Can I use forward declaration for a class in order to put it's definition and Implementation later in the program after it's been used (similar to what is done about functions)?

(I need to join multiple source files of a program into a file, and i want to put the classes' definitions and Implementations at the end of the file in order to main be at the top of the file.)

Upvotes: 0

Views: 397

Answers (2)

antonijn
antonijn

Reputation: 5760

Yes you can, to a certain extent.

You have to realize that the C++ compiler is quite stupid, and doesn't read ahead. This is the reason why you have to use function prototypes (among some other reasons). Now, a function isn't hard for compiler to resolve. It just looks at the return type of the function, and the types of the parameters of the function, and just assumes that the function is there, without any knowledge about what's actually inside the function, because it ultimately doesn't matter at that point.

However, the contents of the class do matter (the compiler needs to know the size of the class for example). But remember about the not reading ahead bit? When you forward define a class, the compiler doesn't know about what's in it, and therefore is missing a lot of information about it. How much space does is need to reserve for example?

Therefore, you can forward define classes, but you can't use them as value types. The only thing you can do with it (before it has been concretely declared), is use pointers to it (and use it as a function return type and template argument, as pointer out by @Cheersandhth.-Alf).

If the thing you need to use isn't a pointer, you should probably use headers (read this if you want to learn more about that).

Upvotes: 2

Cheers and hth. - Alf
Cheers and hth. - Alf

Reputation: 145457

Without a class definition somewhere earlier, you can't use any class members, nor can you create any instances, but you can

  • use T* and T& types,

  • use T for formal return type and parameter declarations (yes even by value),

  • use T as a template parameter,

and possibly more, but the above is what occurred to me immediately.

So if that's all you need, then you're set to go with the forward-declarations.

However, all that the forward declaring buys you in the sketched situation is added work, maintaining the same code in two places, so it's difficult to see the point of it…

Oh, I just remembered, there is a particularly nasty Undefined Behavior associated with forward-declared incomplete types, namely using delete p where p is a pointer to incomplete type. This requires the destructor to be trivial. If the compiler is good then it warns, but don't count on it.

In summary, I would just place main at the very end of that code, where it belongs, avoiding all the problems.

Upvotes: 1

Related Questions