Why a variable can't be defined twice in 2 fil

Why can't I have int a; in 2 C files. I intend to combine both to make executable. I know from experience that I can't, but I want to find where the standard C99 says this and seal my understanding.

I am reading ISO C99 standard from http://www.open-std.org/jtc1/sc22/wg...docs/n1256.pdf. It says on page 42:

6.2.2 Linkages of identiﬁers

1 An identiﬁer declared in different scopes or in the same scope more than once can be made to refer to the same object or function by a process called linkage.There are three kinds of linkage: external, internal, and none.

2 In the set of translation units and libraries that constitutes an entire program, each declaration of a particular identiﬁer with external linkage denotes the same object or function. Within one translation unit, each declaration of an identiﬁer with internal linkage denotes the same object or function. Each declaration of an identiﬁer with no linkage denotes a unique entity.

3 If the declaration of a ﬁle scope identiﬁer for an object or a function contains the storage-class speciﬁer static,the identiﬁer has internal linkage.

4 For an identiﬁer declared with the storage-class speciﬁer extern in a scope in which a prior declaration of that identiﬁer is visible,if the prior declaration speciﬁes internal or external linkage, the linkage of the identiﬁer at the later declaration is the same as the linkage speciﬁed at the prior declaration. If no prior declaration is visible, or if the prior declaration speciﬁes no linkage, then the identiﬁer has external linkage.

5 If the declaration of an identiﬁer for a function has no storage-class speciﬁer,its linkage is determined exactly as if it were declared with the storage-class speciﬁer extern.If the declaration of an identiﬁer for an object has ﬁle scope and no storage-class speciﬁer, its linkage is external.

After reading this it looks that if I declare a variable like say int a; in 2 source files. then both have external linkage as per rule 5 and 4. and then as per rule 2, both should refer to the same object. Then why does the compiler create problem. Where in the standard it is hinted that we can't declare like this in 2 source files and this should throw compilation error. Firstly, where in the standard, it says that int a is a definition, and then where it says that 2 instances of definitions are not acceptable. I know that it is not allowed from my experience, but it would be very useful to me, if I can find this in the standard and seal my understanding.

Do the following excerpts from the standard in combination amount to this rule? or I have missed that glue? :

A declaration speciﬁes the interpretation and attributes of a set of identiﬁers. A deﬁnition of an identiﬁer is a declaration for that identiﬁer that: —for an object, causes storage to be reserved for that object; —for a function, includes the function body; —for an enumeration constant or typedef name, is the (only) declaration of the identiﬁer.

As discussed in 5.1.1.1, the unit of program text after preprocessing is a translation unit, which consists of a sequence of external declarations. These are described as ‘‘external’’ because theyappear outside anyfunction (and hence have ﬁle scope). As discussed in 6.7, a declaration that also causes storage to be reserved for an object or a function named by the identiﬁer is a deﬁnition.

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

Thanks.

I think you need 6.9.2/2:

A declaration of an identifier for an object that has file scope without an initializer, and without a storage-class specifier or with the storage-class specifier static, constitutes a tentative definition. If a translation unit contains one or more tentative definitions for an identifier, and the translation unit contains no external definition for that identifier, then the behavior is exactly as if the translation unit contains a file scope declaration of that identifier, with the composite type as of the end of the translation unit, with an initializer equal to 0.

and 6.9/5:

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 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.

Basically, int a; is a tentative definition. You can have multiple tentative definitions in a single translation unit but the effect is the same as having one non-tentative external definition (e.g. something like int a = 0;). Having more that one definition of an object with external linkage in a program is a violation of 6.9/5.

Note that it is a "common extension" to allow more than one external definitions of an object so long as at most only one is initialized and the definitions agree (see J.5.11).