circular includes?

I'm doing work and I think the trouble I'm having is with circular includes.

I have Unit as a base class, and Hero and Army both derive from Unit.
Hero needs to have a vector of Army*'s, and Army needs to have a single Hero*. Here is how the code is setup:

Code:

#ifndef ARMY_H
#define ARMY_H

#include "Unit.h"
#include "Hero.h"

using namespace std;

class Army : public Unit
{
public:
	Hero* getHero(){return phero;}
	void setHero(Hero *theHero){phero = theHero;}

private:
	Hero *phero;
// ... etc

and

Code:

#ifndef HERO_H
#define HERO_H

#include<iostream>
#include "Army.h"
#include <string>
#include<vector>

using namespace std;

class Hero : public Unit
{
public:
	void addArmy(Army*);
	void removeArmy(Army*);
private:
	vector<Army*> army;
// ... etc

But when it's trying to compile Hero, it sees that Army is included, so it tries to compile that, which says that Hero is included, etc. So I believe I've reached a circular include.

Is there any way to achieve this functionality without doing a restructure of my classes? Thanks for help.

nevermind, i found a way through in intermediary class

Intermediary class is one way. You might also want to do a search for "forward declaration".

How do you declare an object when two classes have pointers to each other?

Originally Posted by 7stud

How do you declare an object when two classes have pointers to each other?

Often a forward declaration is used.

declare a class <---->declare an object.

How do you declare an object of one of the classes in main()?

Code:

#include <iostream>
using namespace std;

using namespace std;

class B;

class A
{
public:
	A(B* ptr, int n)
	{
		pB = ptr;
		num = n;
	}

	int get()
	{
		return num;
	}

private:
	B* pB;
	int num;
};

class B
{
public:
	B(A* ptr, int n)
	{
		pA = ptr;
		num = n;
	}

	int get()
	{
		return num;
	}
private:

	A* pA;
	int num;
};


int main()
{
	

    return 0;
}

Do you have to use a default constructor?

Originally Posted by 7stud

How do you declare an object when two classes have pointers to each other?

I guess define might have been a better term.

Declare a class; define an object.

If one has to exist before the other, and it needs to point to something that may not yet exist, I'd say that a default constructor should be necessary for at least one of the them. But perhaps it depends on the scope of the objects.

Code:

#include <iostream>
using namespace std;

class B;

class A
{
   B* pB;
public:
   A(B* ptr) : pB(ptr) {}
   friend ostream& operator<< (ostream& o, const A &a)
   {
      return o << a.pB;
   }
};

class B
{
   A* pA;
public:
   B(A* ptr) : pA(ptr) {}
   friend ostream& operator<< (ostream& o, const B &b)
   {
      return o << b.pA;
   }
};

extern B b;
A a(&b);
B b(&a);

int main()
{
   cout << a << endl;
   cout << b << endl;
   return 0;
}