C++ Where to define globals (Linker Error: Symbol already defined) - c++

Question

I googled for about 30 minutes now and didnt find anything related to my problem:
I use Visual Studio C++ 2008, it declared a header for me called "stdafx.h"
in this header i declared all stuff i need, an i want the global variables to be in there too, but when i want to use one of these variables, i get an error (at compiling time)
my "stdafx.h" looks like this:
#pragma once
#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
// Windows Header Files:
windows header here....
// C RunTime Header Files
compiler related standard headers here....
// TODO: reference additional headers your program requires here
#ifndef aaab
#include "codename.hpp"
#define aaab
#endif
// and a load of other headers (all of my project) followed here
...
...
...
and after the declarations i defined my globals like:
Game *game;
and i want to use them in "codename.cpp"
here a short view of the class
#include "stdafx.h"
#define MAX_LOADSTRING 100
other class related stuff here....
main function here....
void test()
{
game = new Game(); // HERE IS THE ERROR
}

Answer 1

You probably need to declare your global as extern in the header file:
extern Game *game;
Then define it in a .cpp file.

Answer 2

Here are some methods to handle global variables:
Define in separate namespace
Cluster into a static class
Static source with accessor functions
Define in global namespace
In any situation, the preferred method is to declare the variable in a header file and define it in a source file.
Separate Namespace
This is better than a variable declared in the global namespace since it reduces the likelihood of collision with other variables and reduces contamination by other functions.
Example:
namespace Math_Globals
{
int a_math_int;
}
Clustered in static class
Other languages don't allow global variables so they must be clustered into a class. Making them static inside a class and the class static provides for only one instance. Similar to a singleton pattern.
This design allows you to cluster your globals and provides more protection against collision and unauthorized access. The more difficult to access the variable, the less likely a programmer is to use it (and provide collision & unauthorized access).
Example:
static class Math_Globals
{
public:
static int math_global; // Declaration.
};
int Math_Globals::math_global; // This is how it would be defined.
Static in module with accessor functions
A common safeguard in the C language is to define the variable static in a source module and provide public accessor functions. This allows for some access control.
Example:
Header.hpp:
int Get_Math_Global(void);
void Set_Math_Global(int new_value);
Source.cpp:
static int my_math_global = INITIAL_VALUE;
int Get_Math_Global(void)
{
return my_math_global;
}
void Set_Math_Global(int new_value)
{
my_math_global = new_value;
return;
}
Global Namespace
The consensus among programmers is that variables defined in the global namespace is evil. Some say that any of the above methods (or other methods) is preferred.
Global variables may lead to strongly coupled functions and modules which are difficult to reuse. Also in debugging, finding the function that changed the variable's state to an unexpected value is difficult, or time consuming.

Answer 3

You are declaring a global variable named ggg on a header, included from two or more .cpp.
Global variables should only be declared on a .cpp, and optionally defined as external on an .h.
Solution:
Find the ggg declaration.
Add the extern keyword before it.
Create a new global variable on a .cpp named ggg.