... there was an declaration like...
extern const a;
But as a rule const shoule be initialised where it is defined...
Yes.
but we do not initialise extern where we declare it....So what
is exactly happening here?
This is, quite simply, not a definition.
In C, when you name a variable's existence, you can *define* the
variable:
int foo = 42;
or merely *declare* the variable:
extern float bar;
If you define it, this also declares it (every definition is also
a declaration), but if you merely declare it, you do not define it.
For variables declared outside a function, the declaration is also
a definition if the variable is initialized, but is normally just
a declaration if the "extern" keyword is used. (If you do both --
write the "extern" keyword, then initialize it anyway -- you get
a definition, so:
extern int foo = 42;
means the same thing as the first definition above.)
There is a third state, sort of between the two, called a "tentative
definition". You get this when you omit the "extern" keyword, but
also omit the initializer:
char *tentative;
In this case, the variable is "tentatively defined" from that point
forward in the translation unit, up until the compiler sees a
(non-tentative, for-sure for-real) definition:
char *zorg; /* initially, tentative */
char *zorg = "evil"; /* now, defined */
or the translation unit ends. If the translation unit ends and no
definition has occurred, the effect is the same[%] as if you had added,
just at the end, an actual definition with an initializer of {0}:
char *tentative;
/* if the file ends, now, this means:
char *tentative = {0};
which makes it initially NULL. */
Again, these rules apply ONLY to file-scope variables (those outside
function blocks). Inside a function, there is no such thing as a
"tentative definition":
void f(void) {
int x; /* actually defines x, which contains no useful value,
so be sure to give it one before using it */
}
-----
[%] In some implementations, "tentative definition" variables are
treated specially, and multiple tentative definitions in separate
translation units are simply merged at link time. The C Standards
(C89 and C99 both) say that this situation is undefined, so
implementations can define it, if they like. Other implementations
make it an error. One popular implementation (GCC) can be told
to behave either way.
