Thread: Inter-dependant classes

I have 3 classes each of which is related to the other 2 in some way. The problem is to define, lets say, the first class; I have to first define the class that appears in it. IE. to define UnitInstance, I have to first define SetOfOrders. But to define SetOfOrders I have to first define Order. But to define Order, I have to define UnitInstance. And so on and so forth....

I originally had these in seperate files, but the same problem occurs (It's just a lot harder to see).

This code appears in one of the headers:

Code:

class UnitInstance {
public:
	SetOfOrders UnitOrders;
	// Other variables & function prototypes.
};


class Order {
public:
	UnitInstance *Unit1;
	// Other variables & function prototypes.
};


class SetOfOrders {
public:
	Order *Orders;
	// Other variables & function prototypes.
};

Note that in the Order class, Unit1 is a pointer to another entirely different UnitInstance (or may even be null) - so it's not as if I was trying to allocate memory in cycle.

If it makes any difference I'm using Microsoft Visual C++ 6.0 Pro.

How should I fix this? Is there a keyword I should be using - should I be arranging these classes in a certain order - are there any compiler options I should be setting?

You can declare classes, just like you declare functions, before you define them. Example:

Code:

class a;
class b;
class c;

class a
{
	public: b *b1;
};
class b
{
	public: c *c1;
};
class c
{
	public: a *a1;
};

You need to use a forward declaration.

Code:

class Order;

class SetOfOrders {
public:
	Order *Orders;
	// Other variables & function prototypes.
};

class UnitInstance {
public:
	SetOfOrders UnitOrders;
	// Other variables & function prototypes.
};


class Order {
public:
	UnitInstance *Unit1;
	// Other variables & function prototypes.
};

Thanks a lot for that. Part of me knew it was that easy......

And those forward declarations will save you a lot of headache. I personally think they are clunky and ugly, but they do work and since C++ has no other way of dealing with the problem of A needs B but B needs A, we are stuck with it.

In your header files, you should prefer forward declarations over #including the headers that declare the other class if it will work.

I might be mistaken but forward declaration only works in the case that the header being defined only uses pointers to the other needed class. Take for instance:

Code:

//forward declaration
class classA;

class classB
{
protected:
    classA *m_ptr;

public:

...

};

This will work since you define only a ptr to classA so classA object size is not important since you won't be allocating a classA object on stack but only a pointer to it and a pointer is always the same size, if on the other hand you had a class:

Code:

//forward declaration
class classA;

class classB
{
protected:
    classA m_obj;

...
};

Now this wouldn't work without including the header file for classA since for creating an instance of classB you'll need to allocate space for an instance of classA.

Cheers

You are correct, although there are other cases besides pointer members where a forward declaration will do, including reference members and function parameters.

I thought so, and thanks for the correction there Daved