I would like to know why you can not declare a global with the same name in 2 different .cpp files. My understanding is considering scope, that it should only be visible to that particular .cpp file and no where else but it is obviously complaining. The reason I'm doing this is for commonality in code and that's it. any ideas?
Edit for Clarity
a.cpp
int g_x;
b.cpp
int g_x;
To make a global variable (or function) only visible to the file it's declared in,
static, or To access a global variable (that is not static or in an anonymous namespace) that is declared in some other file, use extern.
The reason why is the same reason why you can't have a function with the same name in two different files. It confuses the linker because global variables by default have external linkage. static or being in an anonymous namespace gives them internal linkage, which makes them like a "local global variable".
The Problem:
Global variables have External linkage, i.e: They are visible throughout the program.
if 2 different files have variable with same symbol name then it breaks the ODR(One Definition Rule).
The One Definition Rule (ODR), as the name suggests, requires that an object with external linkage, a non-inline function, a class, an enumeration or a template shall have exactly one definition in the program.
The Solution:
Your global variables in the files should have Internal Linkage to avoid violation of ODR.
There are two ways to achieve this:
Make your global variables in file static Or
Use Anonymous/Unnamed namespace.
Good Read:
Anonymous/Unnamed namespace
Speaking Standardese: the One Definition Rule
For Standerdese Fans:
C++11 3.2 One Definition Rule [basic.def.odr]:
No translation unit shall contain more than one definition of any variable, function, class type, enumeration type or template.
Para 3:
Every program shall contain exactly one definition of every non-inline function or variable that is odr-used in that program; no diagnostic required. The definition can appear explicitly in the program, it can be found in the standard or a user-defined library, or (when appropriate) it is implicitly defined (see 12.1, 12.4 and 12.8). An inline function shall be defined in every translation unit in which it is odr-used.
C++11 7.3.1.1 Unnamed namespaces [namespace.unnamed]
1/ An unnamed-namespace-definition behaves as if it were replaced by
inlineoptnamespace unique { /* empty body */ }
using namespace unique ;
namespace unique { namespace-body }
where inline appears if and only if it appears in the unnamed-namespace-definition, all occurrences of unique in a translation unit are replaced by the same identifier, and this identifier differs from all other identifiers in the entire program.94
Note: C++03 deprecated usage of static for declaring objects in namespace scope but this deprecation was removed in C++11.
The reason why you get linker errors is because the variables have extern linkage, and are in the same namespace (namely the global one).
And the usual and recommended remedy is to put them in separate namespaces.
You can accomplish that by using an anonymous namespace, like so:
namespace {
int my_global_variable;
}
This namespace gets a unique name in each translation unit. Say, in one translation unit the automatic name could be “gorblegorble123”. And this works as if the compiler places the following code after it:
using namespace gorblegorble123; // As if this is present.
And ditto in other translation unit, but with different unique names.
This is the most general technique. In particular it works with class definitions.
As mentioned in some other answers you can alternatively use static to specify internal linkage, that the variable is not visible to the linker.
This usage was deprecated for objects in namespace scope in C++98 and C++03, but the deprecation was removed in C++11.
static is a limited special cases notation that can be applied to objects and functions, but not to classes.
Declare the variable static (C and C++):
static int myGlobalVariable;
or declare it in an anonymous namespace (C++ only):
namespace {
int myGlobalVariable;
}
why you can not declare a global with the same name in 2 different .cpp files
Because any program that has multiple definitions of a single entity is ill-formed. In your case, you have two entities named the same thing, therefore the program is ill-formed.
The preferred method (In C++03 at least) to resolve this is to use unnamed namespaces:
namespace
{
int n;
};
namespace
{
int n;
};
Placing a declaration within an unnamed namespace makes that entity visible only within that translation unit.
Since the question is also tagged 'c', I'd like to add my 5 cents. In C there is no "one definition rule".
In C (C99 and before, not sure about C1x) an object with file scope and without a storage class specifier constitutes a tentative definition. (section 6.9.2).
In the subsequent Example 1 on page 144, several examples are listed, concentrating all on definitions/declarations within one file.
However, an extern declaration together with a declaration without storage class specifier (i3) go together well and constitute a definition with external linkage.
This means that a second file may exist referring to that definition either using extern as well, or again without storage class specifier.
So in C, you may have two files both with tentative definitions like
int i3;
and both will refer to one variable of tupe int, and the linker will make sure the both refer to the same memory location.
And even if you have int abc; and char abc in two different files, the regular linker will not produce an error; hopefully it will warn you, though.
H&S5 has some more details on how various types of linkers will handle such a situation, but using the common memory model, the above is confirmed. At least IMHO.
For further references, look here, especially the answer by Alok.
