By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
455,907 Members | 1,283 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 455,907 IT Pros & Developers. It's quick & easy.

const and extern...

P: n/a
When I read about volatile keyword....while explaning there was an
declaration like...
extern const a;

But as a rule const shoule be initialised where it is defined...but we
do ot initialise extern where we declare it....So what is exactly
happening here?

May 27 '07 #1
Share this Question
Share on Google+
2 Replies


P: n/a
Shraddha wrote:
When I read about volatile keyword....while explaning there was an
declaration like...
extern const a;

But as a rule const shoule be initialised where it is defined...but we
do ot initialise extern where we declare it....So what is exactly
happening here?
It's being declared. It must be defined once in the application.

--
Ian Collins.
May 27 '07 #2

P: n/a
In article <11**********************@q19g2000prn.googlegroups .com>
Shraddha <sh*************@gmail.comwrote:
>... 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.
--
In-Real-Life: Chris Torek, Wind River Systems
Salt Lake City, UT, USA (4039.22'N, 11150.29'W) +1 801 277 2603
email: forget about it http://web.torek.net/torek/index.html
Reading email is like searching for food in the garbage, thanks to spammers.
May 27 '07 #3

This discussion thread is closed

Replies have been disabled for this discussion.