Confused on Class scopes

Please help me resolve my class scopes

Code:

// First.h
#include "Second.h"
class First
{

};

Code:

// Second.h
#include "Third.h"
class Second
{

};

Code:

// Third.h
#include "Fourth.h"
class Third
{

};

Code:

// Fourth.h
#include "First.h"
class Fourth
{
// Got an error here because First includes Second, which includes third, which includes 'this'
};

I need to use class First in fourth, how do i do that?

You can start with some inclusion guards:

Code:

#ifndef FIRST_H
#define FIRST_H
// First.h
#include "Second.h"
class First
{

};
#endif

Code:

#ifndef SECOND_H
#define SECOND_H
// Second.h
#include "Third.h"
class Second
{

};
#endif

Code:

#ifndef THIRD_H
#define THIRD_H
// Third.h
#include "Fourth.h"
class Third
{

};
#endif

Code:

#ifndef FOURTH_H
#define FOURTH_H
// Fourth.h
#include "First.h"
class Fourth
{
// Got an error here because First includes Second, which includes third, which includes 'this'
};
#endif

That might be what you're seeing.

You need include guards. Then you won't recursively include things.

--
Mats

I need to use class First in fourth, how do i do that?

You have a cyclic dependency that means you'll need to break it with forward declarations.

Generally any header that doesn't need to know the full definition of a type shouldn't include that header, but forward-declare the type in question. Implementation files (*.cpp) generally need to know the full definition of the forward-declared types, so this is where you include most headers.

Just a quick question. Hopefully this isn't hijacking the thread too much.

When is it cool to use "#define"?

We need it for inclusion guards as seen here, however we are told not to use it to define constants, and to instead use the 'const' keyword instead.

Why is one use outdated and the other not? Are they different somehow?

Originally Posted by Stonehambey

Just a quick question. Hopefully this isn't hijacking the thread too much.

When is it cool to use "#define"?

We need it for inclusion guards as seen here, however we are told not to use it to define constants, and to instead use the 'const' keyword instead.

Why is one use outdated and the other not? Are they different somehow?

It's acceptable to use #define for things that need the preprocessor to resolve the problem. In this case, you CAN NOT use const int, because that requires the compiler, and by that time, it's too late to not have a second copy of "first.h" content in the compiler input.

For most other purposes, const is a better idea.

For plain and simple number constants, #define works OK, with the only drawback that the debugger can't tell you the value of X with#define X 7, whilst a const int x = 7, the debugger should be able to tell you that x = 7.

Edit: Perhaps a moderator can split this off, as it's pretty unrelated to the original thread.

--
Mats

Cheers

>> #define works OK, with the only drawback that the debugger can't tell you the value of X
That's not the only drawback. #defines don't follow type or scope rules.

>> You have a cyclic dependency that means you'll need to break it with forward declarations.
For example, you can generally forward declarate First in Fourth.h if First is not a member of Fourth and you don't call any member functions of First from inside the header. If you're using a pointer or reference to First inside Fourth.h then a forward declaration should be fine.

Note that it is impossible for each class to hold a member of the previous one in the cycle, because then you'd have an infinitely recursive nesting of objects, so somewhere it should be possible to break the cycle with a forward declaration if not everywhere.

Here's my problem

Code:

#ifndef MENUCONTEXT_H
#define MENUCONTEXT_H

#include "FleetMenu.h"

// Class MenuContext
class MenuContext 
{
public:
	bool fquit;
	
	FleetMenu *menuPrt;  // NB ** Errors below are related to this line

	MenuContext(FleetMenu *m) : fquit(false), menuPtr = m {}
	~MenuContext() {};
};
typedef void (*MenuFunc)(MenuContext &ctxt);

#endif

Code:

#ifndef FLEETMENU_H
#define FLEETMENU_H

#include "Menu.h"


class FleetMenu
{
public:

	FleetMenu();
	void RunFleet();

	// Menu functions
	static void Exit(MenuContext &ctxt);

private:

	typedef vector<Car> CarFleet;
	typedef CarFleet::iterator FleetIterator;

private:
	CarFleet fleet; 
};

#endif

Code:

 // Class menu
#ifndef MENU_H
#define MENU_H

#include "MenuItem.h"

class Menu 
{
private:
	struct MenuNode {
		MenuNode *next;
		MenuItem *item;
	};

	MenuNode *head;
	MenuNode *tail;

public:
	Menu();
	~Menu();

	void addMenu(std::string s, char c, MenuFunc f);
	void choose(MenuContext &ctxt);
};

#endif

Code:

// Class: Menuitem
#ifndef MENUITEM_H
#define MENUITEM_H

#include "MenuContext.h"

using namespace std;

class MenuItem 
{
private:
	std::string	descr;
	char        choice;
	MenuFunc    func;

public:
	MenuItem(const std::string &s, char c, MenuFunc f);
	~MenuItem();
	void print();
	std::string whiteSpace(int slenght, char space);
	void doMenu(MenuContext &ctxt);
	bool isChoice(char c);
};

#end

Code:

// Errors

// : error C2143: syntax error : missing ';' before '*'
// : error C4430: missing type specifier - int assumed. Note: C++ does not support default-int
// : error C4430: missing type specifier - int assumed. Note: C++ does not support default-int
// : error C2143: syntax error : missing ')' before '*'

// etc

Mostly these errors are linked to scope

Ok, let's see what header needs to include which headers:

Code:

#ifndef MENUCONTEXT_H
#define MENUCONTEXT_H

#include "FleetMenu.h"

// Class MenuContext
class MenuContext 
{
public:
	bool fquit;
	
	FleetMenu *menuPrt;  // NB ** Errors below are related to this line

	MenuContext(FleetMenu *m) : fquit(false), menuPtr = m {}
	~MenuContext() {};
};
typedef void (*MenuFunc)(MenuContext &ctxt);

#endif

If I'm not mistaken this header doesn't need the full definition of FleetMenu, because it only deals with pointers to FleetMenu. Hence you should be able to replace the inclusion with a forward declaration:

Code:

class FleetMenu;

Similarly:
"fleetmenu.h" - since FleetMenu contains an instance of CarFleet, you need to include the header where it is defined. MenuContext is referred to only as a reference, so a forward declaration should be enough. This header might also need to include <vector>.

"menu.h" - probably needs to include the header where MenuFunc is typedeffed. MenuContext could be forward declared (but it is defined in the same header anyway).

"menu_item.h" - needs to include <string> and "menu_context.h" for the typedef of MenuFunc.

All in all:
"menu_context.h" -> includes nothing
"fleet_menu.h" -> includes <vector>, "car_fleet.h"(?)
"menu.h" -> includes "menu_context.h"
"menu_item.h" -> includes <string>, "menu_context.h"

and there should be no more circular inclusions.

In short, forward-declare what you can and include what you need in headers. If the full type is needed for implementation, include the respective header in the CPP-file (if it was only forward-declared in the header).

Originally Posted by anon

All in all:
"menu_context.h" -> includes nothing
"fleet_menu.h" -> includes <vector>, "car_fleet.h"(?)
"menu.h" -> includes "menu_context.h"
"menu_item.h" -> includes <string>, "menu_context.h"

and there should be no more circular inclusions.

In short, forward-declare what you can and include what you need in headers. If the full type is needed for implementation, include the respective header in the CPP-file (if it was only forward-declared in the header).

Hi Anon, Yes, i have do have Car, vector, string includes already... I did cut my code short to avoid too much code. But i now understand what "forward declaration" means...

Thanx