Class forward declaration ignored?

[Zyl]

Hello.

I have a class "SelectionGroup" which derives from a class "RMFObjectContainer".
RMFObjectContainer has member variables of type SelectionGroup, so I need to include SelectionGroup.h in the header of RMFObjectContainer.h.

However, since SelectionGroup needs RMFObjectContainer to derive from it, I get a typical case of mutual inclusion.

I then proceeded to put the forward declaration
class RMFObjectContainer;
instead of
#include "RMFObjectContainer.h"
into the header of SelectionGroup.h.

However, I receive the following compile error (MSVC2010), as if the forward declaration was unseen:

1>d:\projects\programming\c++\bsc_volumetric_lighting\bsc_volumetric_lighting\rmf\SelectionGroup.h(8): error C2504: 'RMFObjectContainer' : base class undefined

I assume this is a special problem resulting from me using .h files and leaving .cpp files empty, or I have a misunderstanding regarding #pragma once, and some special handling kicks in?


Code:

RMFObjectContainer.h:

#pragma once

#include "Solid.h"
#include "Entity.h"
#include "SelectionGroup.h"

class RMFObjectContainer : public RMFObject
{
public:
	RMFObjectContainer::RMFObjectContainer(void) {
		
		solids = (Solid**) malloc(sizeof(Solid*));
		solidCount = 0;
		
		entities = (Entity**) malloc(sizeof(Entity*));
		entityCount = 0;
		
		groups = (SelectionGroup**) malloc(sizeof(SelectionGroup*));
		groupCount = 0;
	}

	RMFObjectContainer::~RMFObjectContainer(void) {
	}

	int getSolidCount() {
		return this->solidCount;
	}

	void addSolid(Solid* s) {
		solids = (Solid**) realloc(solids, sizeof(Solid*) * (solidCount + 1));
		*(solids + solidCount) = s;
		solidCount++;
	}

	// Uses insert order
	Solid* getSolid(int number) {
		if (number >= solidCount || number <= 0)
			return NULL;
		return *(solids + number);
	}

	int getEntityCount() {
		return this->entityCount;
	}

	void addEntity(Entity* e) {
		entities = (Entity**) realloc(entities, sizeof(Entity*) * (entityCount + 1));
		*(entities + entityCount) = e;
		entityCount++;
	}

	// Uses insert order
	Entity* getEntity(int number) {
		if (number >= entityCount || number <= 0)
			return NULL;
		return *(entities + number);
	}

	int getGroupCount() {
		return this->groupCount;
	}

	void addGroup(SelectionGroup* g) {
		groups = (SelectionGroup**) realloc(groups, sizeof(SelectionGroup*) * (groupCount + 1));
		*(groups + groupCount) = g;
		groupCount++;
	}

	// Uses insert order
	SelectionGroup* getGroup(int number) {
		if (number >= groupCount || number <= 0)
			return NULL;
		return *(groups + number);
	}

private:
	Solid** solids;
	int solidCount;

	Entity** entities;
	int entityCount;

	SelectionGroup** groups;
	int groupCount;
};

^ Solid.h and Entity.h include a few other headers which are unrelated.


SelectionGroup.h:

#pragma once

//#include "RMFObjectContainer.h"

class RMFObjectContainer;

class SelectionGroup : public RMFObjectContainer
{
public:
	SelectionGroup::SelectionGroup(void) {
	}

	SelectionGroup::~SelectionGroup(void) {
	}
};

Any help is appreciated! Thanks in advance!

[coder777]

replace line 5 in RMFObjectContainer.h with class SelectionGroup;

remove line 5 in SelectionGroup.h and uncomment line 3

[Zyl]

That way worked. Thank you.

I assume forward declarations of base classes are a nono?

[MikeyBoy]

I assume forward declarations of base classes are a nono?

Correct. You can only use forward declaration in situations where the compiler needs to know nothing at all about the actual class definition. This basically boils down to when it's declaring pointers or references, or passing pointers and references around without actually doing anything with them.

Unsurprisingly, when you inherit from a base class, the compiler needs to know the definition of the base class :)

[Zyl]

Yeah, it makes sense it needs the actual definition to take care of all the OOP fancy.

Thanks for clarifying, MikeyBoy!

Marking this as solved.