Home     |     .Net Programming    |     cSharp Home    |     Sql Server Home    |     Javascript / Client Side Development     |     Ajax Programming

Ruby on Rails Development     |     Perl Programming     |     C Programming Language     |     C++ Programming     |     IT Jobs

Python Programming Language     |     Laptop Suggestions?    |     TCL Scripting     |     Fortran Programming     |     Scheme Programming Language


 
 
Cervo Technologies
The Right Source to Outsource

MS Dynamics CRM 3.0

C Programming Language

const and extern...


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?

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.

In article <1180240961.469920.261@q19g2000prn.googlegroups.com>

Shraddha  <shraddhajosh@gmail.com> wrote:
>... 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.

Add to del.icio.us | Digg this | Stumble it | Powered by Megasolutions Inc