If I don't odr-use a variable, can I have multiple definitions of it across translation units?

Question

The standard seems to imply that there is no restriction on the number of definitions of a variable if it is not odr-used (§3.2/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.

It does say that any variable can't be defined multiple times within a translation unit (§3.2/1):

No translation unit shall contain more than one definition of any variable, function, class type, enumeration type, or template.

But I can't find a restriction for non-odr-used variables across the entire program. So why can't I compile something like the following:

// other.cpp
int x;

// main.cpp
int x;
int main() {}

Compiling and linking these files with g++ 4.6.3, I get a linker error for multiple definition of 'x'. To be honest, I expect this, but since x is not odr-used anywhere (as far as I can tell), I can't see how the standard restricts this. Or is it undefined behaviour?

Answer 1

Your program violates the linkage rules. C++11 §3.5[basic.link]/9 states:

Two names that are the same and that are declared in different scopes shall denote the same variable, function, type, enumerator, template or namespace if

• both names have external linkage or else both names have internal linkage and are declared in the same translation unit; and

• both names refer to members of the same namespace or to members, not by inheritance, of the same class; and

• when both names denote functions, the parameter-type-lists of the functions are identical; and

• when both names denote function templates, the signatures are the same.

(I've cited the complete paragraph, for reference. The second two bullets do not apply here.)

In your program, there are two names x, which are the same. They are declared in different scopes (in this case, they are declared in different translation units). Both names have external linkage and both names refer to members of the same namespace (the global namespace).

These two names do not denote the same variable. The declaration int x; defines a variable. Because there are two such definitions in the program, there are two variables in the program. The name "x" in one translation unit denotes one of these variables; the name "x" in the other translation unit denotes the other. Therefore, the program is ill-formed.

Answer 2

You're correct that the standard is at fault in this regard. I have a feeling that this case falls into the gap between 3.2p1 (at most one definition per translation unit, as in your question) and 3.2p6 (which describes how classes, enumerations, inline functions, and various templates can have duplicate definitions across translation units).

For comparison, in C, 6.9p5 requires that (my emphasis):

An external definition is an external declaration that is also a definition of a function (other than an inline definition) or an object. If an identifier declared with external linkage is used in an expression (other than as part of the operand of a sizeof or _Alignof operator whose result is an integer constant), somewhere in the entire program there shall be exactly one external definition for the identifier; otherwise, there shall be no more than one.

Answer 3

If standard does not say anything about definitions of unused variables then you can not imply that there may be multiple:

Undefined behavior may also be expected when this International Standard omits the description of any explicit definition of behavior.

So it may compile and run nicely or may stop during translation with error message or may crash runtime etc.

EDIT: See James McNellis answer the standard indeed actually has rules about it.

Answer 4

There is no error in compiling that, the error is in its linkage. By default your global variable or functions are public to other files(have extern storage) so at the end when linker want to link your code it see two definition for x and it can't select one of them, so if you do not use x of main.cpp in other.cpp and vice-verse make them static(that means only visible to the file that contain it)

// other.cpp
static int x;

// main.cpp
static int x;