C++ #include guards
Solution 1
The preprocessor is a program that takes your program, makes some changes (for example include files (#include), macro expansion (#define), and basically everything that starts with #
) and gives the "clean" result to the compiler.
The preprocessor works like this when it sees #include
:
When you write:
#include "some_file"
The contents of some_file
almost literally get copy pasted into the file including it. Now if you have:
a.h:
class A { int a; };
And:
b.h:
#include "a.h"
class B { int b; };
And:
main.cpp:
#include "a.h"
#include "b.h"
You get:
main.cpp:
class A { int a; }; // From #include "a.h"
class A { int a; }; // From #include "b.h"
class B { int b; }; // From #include "b.h"
Now you can see how A
is redefined.
When you write guards, they become like this:
a.h:
#ifndef A_H
#define A_H
class A { int a; };
#endif
b.h:
#ifndef B_H
#define B_H
#include "a.h"
class B { int b; };
#endif
So now let's look at how #include
s in main would be expanded (this is exactly, like the previous case: copy-paste)
main.cpp:
// From #include "a.h"
#ifndef A_H
#define A_H
class A { int a; };
#endif
// From #include "b.h"
#ifndef B_H
#define B_H
#ifndef A_H // From
#define A_H // #include "a.h"
class A { int a; }; // inside
#endif // "b.h"
class B { int b; };
#endif
Now let's follow the preprocessor and see what "real" code comes out of this. I will go line by line:
// From #include "a.h"
Comment. Ignore! Continue:
#ifndef A_H
Is A_H
defined? No! Then continue:
#define A_H
Ok now A_H
is defined. Continue:
class A { int a; };
This is not something for preprocessor, so just leave it be. Continue:
#endif
The previous if
finished here. Continue:
// From #include "b.h"
Comment. Ignore! Continue:
#ifndef B_H
Is B_H
defined? No! Then continue:
#define B_H
Ok now B_H
is defined. Continue:
#ifndef A_H // From
Is A_H
defined? YES! Then ignore until corresponding #endif
:
#define A_H // #include "a.h"
Ignore
class A { int a; }; // inside
Ignore
#endif // "b.h"
The previous if
finished here. Continue:
class B { int b; };
This is not something for preprocessor, so just leave it be. Continue:
#endif
The previous if
finished here.
That is, after the preprocessor is done with the file, this is what the compiler sees:
main.cpp
class A { int a; };
class B { int b; };
So as you can see, anything that can get #include
d in the same file twice, whether directly or indirectly needs to be guarded. Since .h
files are always very likely to be included twice, it is good if you guard ALL your .h files.
P.S. Note that you also have circular #include
s. Imagine the preprocessor copy-pasting the code of Physics.h into GameObject.h which sees there is an #include "GameObject.h"
which means copy GameObject.h
into itself. When you copy, you again get #include "Pysics.h"
and you are stuck in a loop forever. Compilers prevent that, but that means your #include
s are half-done.
Before saying how to fix this, you should know another thing.
If you have:
#include "b.h"
class A
{
B b;
};
Then the compiler needs to know everything about b
, most importantly, what variables it has etc so that it would know how many bytes it should put in place of b
in A
.
However, if you have:
class A
{
B *b;
};
Then the compiler doesn't really need to know anything about B
(since pointers, regardless of the type have the same size). The only thing it needs to know about B
is that it exists!
So you do something called "forward declaration":
class B; // This line just says B exists
class A
{
B *b;
};
This is very similar to many other things you do in header files such as:
int function(int x); // This is forward declaration
class A
{
public:
void do_something(); // This is forward declaration
}
Solution 2
You have circular references here: Physics.h
includes GameObject.h
which includes Physics.h
. Your class Physics
uses GameObject*
(pointer) type so you don't need to include GameObject.h
in Physics.h
but just use forward declaration - instead of
#include "GameObject.h"
put
class GameObject;
Furthermore, put guards in each header file.
Solution 3
Add include guards in all your *.h
or *.hh
header files (unless you have specific reasons to not do that).
To understand what is happening, try to get the preprocessed form of your source code. With GCC, it is something like g++ -Wall -C -E yourcode.cc > yourcode.i
(I have no idea on how Microsoft compilers do that). You can also ask which files are included, with GCC as g++ -Wall -H -c yourcode.cc
Solution 4
Firstly you need include guards on gameobject too, but that's not the real problem here
If something else includes physics.h first, physics.h includes gameobject.h, you get something like this:
class GameObject {
...
};
#include physics.h
class Physics {
...
};
and the #include physics.h gets discarded because of the include guards, and you end up with a declaration of GameObject before the declaration of Physics.
But that's a problem if you want GameObject to have a pointer to a Physics, because for htat physics would have to be declared first.
To resolve the cycle, you can forward-declare a class instead, but only if you are just using it as a pointer or a reference in the declaration following, i.e.:
#ifndef PHYSICS_H
#define PHYSICS_H
// no need for this now #include "GameObject.h"
#include <list>
class GameObject;
class Physics
{
private:
list<GameObject*> objects;
list<GameObject*>::iterator i;
public:
void ApplyPhysics(GameObject*);
Vector2X CheckCollisions(Vector2X, GameObject*);
};
#endif // PHYSICS_H
Solution 5
The issue is that your GameObject.h
does not have guards, so when you #include "GameObject.h"
in Physics.h
it gets included when GameObject.h
includes Physics.h
.
Related videos on Youtube
Orujimaru
Updated on April 23, 2020Comments
-
Orujimaru about 4 years
SOLVED
What really helped me was that I could #include headers in the .cpp file with out causing the redefined error.
I'm new to C++ but I have some programming experience in C# and Java so I could be missing something basic that's unique to C++.
The problem is that I don't really know what's wrong, I will paste some code to try to explain the issue.
I have three Classes, GameEvents, Physics and GameObject. I have headers for each of them. GameEvents has one Physics and a list of GameObjects. Physics has a list of GameObjects.
What I'm trying to achieve is that I want GameObject to be able to access or own a Physics object.
If I simply #include "Physics.h" in GameObject I get the "error C2111: 'ClassXXX' : 'class' type redifinition" which I understand. And this is where I thought #include-guards would help so I added an include guard to my Physics.h since that's the header I want to include twice.
This is how it looks
#ifndef PHYSICS_H #define PHYSICS_H #include "GameObject.h" #include <list> class Physics { private: double gravity; list<GameObject*> objects; list<GameObject*>::iterator i; public: Physics(void); void ApplyPhysics(GameObject*); void UpdatePhysics(int); bool RectangleIntersect(SDL_Rect, SDL_Rect); Vector2X CheckCollisions(Vector2X, GameObject*); }; #endif // PHYSICS_H
But if I #include "Physics.h" in my GameObject.h now like this:
#include "Texture2D.h" #include "Vector2X.h" #include <SDL.h> #include "Physics.h" class GameObject { private: SDL_Rect collisionBox; public: Texture2D texture; Vector2X position; double gravityForce; int weight; bool isOnGround; GameObject(void); GameObject(Texture2D, Vector2X, int); void UpdateObject(int); void Draw(SDL_Surface*); void SetPosition(Vector2X); SDL_Rect GetCollisionBox(); };
I get multiple issues that don't understand why they're showing up. If I don't #include "Physics.h" my code runs just fine.
I'm very grateful for any help.
-
IronMensan over 12 yearsDuplicate of stackoverflow.com/questions/8010601/… and many, many others.
-
-
Orujimaru over 12 yearsI've added guards for all headers but when I replace the #include "GameObject.h" with Class GameObject; Visual Studio returns error for every single line of code in both Physics.cpp and Physics.h. The same happens if I try to forward declare any other class in any header.
-
Orujimaru over 12 yearsThanks, this has helped me a lot and I have a better understanding of what's happening. I have successfully forward declared a Physics *physics in my GameObject.h. but if I understand it correctly I cannot create a Physics in my GameObject, I have to pass an existing pointer to my GameObject.cpp?
-
Orujimaru over 12 yearsI can't seem to understand how I access the physics pointer in my GameObject.cpp If I attempt physics->CheckCollisions() I get "pointer to incomplete class type is not allowed" and no member found.
-
Orujimaru over 12 yearsI solved it, but I'm still a little confused. I forward declared class Physics; in my GameObject.h as well as a Physics *physics; in the GameObject.h body. Then in GameObject.cpp I included "Physics.h" and let the GameEvents pass down a *Physics in the GameObject constructor. This works for me now. Please tell me if this will cause problems in the future. Anyhow I'm very grateful for all your help.
-
Shahbaz over 12 years@Orujimaru I don't see a
Physics
object or pointer in yourGameObject
class, but I see a lot ofGameObject *
s in yourPhysics
class. This suggests forward declaringGameObject
inPhysics.h
rather than the other way around. Either way, when you want to use the class (that is in the.cpp
files), you need to include each header itself. Since you don't include.cpp
files, there is no risk of circular includes! -
Hans about 10 yearsHow does the compiler interpret
A_H
andB_H
in#define
which have not appeared (defined) before? How does it know these are related toa.h
orb.h
? -
Shahbaz about 10 years@hans, it doesn't know they are related to a.h and b.h! The preprocessor first copies a.h and b.h where they are
#include
d. Then it starts looking at what's inside. The first time it sees#define A_H
, well it defines it. In fact this define shouldn't happen twice -
Hans about 10 yearsI was wondering where things like
A_H
was defined, like a file namedA_H
. I think what you are saying is that the lines between#define A_H
and#endif
is the definition ofA_H
. So actually you can say anything completely unrelated toa.h
orb.h
. Am I right? -
Hans about 10 yearsIf the answer to my previous question is positive, my followup question is, when the content (definition) of
#define A_H
is not sandwiched between#ifndef
and#endif
but elsewhere, and extends several lines below#define
, how does the compiler know where the definition ofA_H
ends if there is no such notation as#enddef
? -
Shahbaz about 10 years@hans, no no, the definition of a symbol through
#define
is contained in the same line. For example#define SOME_SYMBOL (some_expression)
means the preprocessor would replaceSOME_SYMBOL
where it sees from that point on with(some_expression)
. If you have#define SOME_SYMBOL
with nothing in front of it, it would replace it every it sees it with nothing. So#define A_H
means "define a symbol namedA_H
which replaces with nothing". The part that is important to us is the "define a symbol namedA_H
", because later we want to have an if on whether the symbol is defined (#ifndef
). -
Shahbaz about 10 yearsBy the way, I arbitrarily chose
A_H
for file nameda.h
just to resemble it. You could have used any other symbol, such asSWEET_HEADER_OF_MINE
. However, naming the guard symbol the same as the header file (or derived from it) helps avoid name collision among many headers. If you use the same guard symbol for two headers, you can imagine what would happen (the second header included would be ignored since that symbol is already defined in the first header). -
Shahbaz about 10 yearsTry reading on the C preprocessor too.
-
Hans about 10 yearsSo,
class A {int a}
has nothing to do with#define A_H
and is truly part of#ifndef...#endif' right? Also
#define A_H` withA_H
being assigned nothing is there only to formally makeA_H
defined, right? -
Martin Bonner supports Monica about 5 years"since pointers, regardless of the type have the same size" That is not true. Pointers to structs and classes have the same size, but pointers to other types can be different.
char*
andvoid*
must be big enough that you can cast to them and back without loss of data. (There have been implementations wheresizeof (void*) > sizeof(struct t*)
.)