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.
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:
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.:
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 asg++ -Wall -H -c yourcode.cc
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:
The contents of
some_file
almost literally get copy pasted into the file including it. Now if you have:And:
And:
You get:
Now you can see how
A
is redefined.When you write guards, they become like this:
So now let's look at how
#include
s in main would be expanded (this is exactly, like the previous case: copy-paste)Now let's follow the preprocessor and see what "real" code comes out of this. I will go line by line:
Comment. Ignore! Continue:
Is
A_H
defined? No! Then continue:Ok now
A_H
is defined. Continue:This is not something for preprocessor, so just leave it be. Continue:
The previous
if
finished here. Continue:Comment. Ignore! Continue:
Is
B_H
defined? No! Then continue:Ok now
B_H
is defined. Continue:Is
A_H
defined? YES! Then ignore until corresponding#endif
:Ignore
Ignore
The previous
if
finished here. Continue:This is not something for preprocessor, so just leave it be. Continue:
The previous
if
finished here.That is, after the preprocessor is done with the file, this is what the compiler sees:
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 copyGameObject.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:
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 ofb
inA
.However, if you have:
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 aboutB
is that it exists!So you do something called "forward declaration":
This is very similar to many other things you do in header files such as:
Use include guards in ALL your header files. Since you are using Visual Studio you could use the
#pragma once
as the first preprocessor definition in all your headers.However I suggest to use the classical approach:
Second read about forward declaration and apply it.
You have circular references here:
Physics.h
includesGameObject.h
which includesPhysics.h
. Your classPhysics
usesGameObject*
(pointer) type so you don't need to includeGameObject.h
inPhysics.h
but just use forward declaration - instead ofput
Furthermore, put guards in each header file.
The issue is that your
GameObject.h
does not have guards, so when you#include "GameObject.h"
inPhysics.h
it gets included whenGameObject.h
includesPhysics.h
.