"Jack Klein" <jackklein@spamcop.net> wrote in message news:uaa8b0pvk0b3j2eqsuldi8qpc6rfrvqado@4ax.com...[color=blue]
> On 25 May 2004 21:26:36 -0700,
pembed2003@yahoo.com (pembed2003) wrote
> in comp.lang.c:
>[color=green]
> > Hi all,
> > I am reading the book "C How to Program" and in the chapter where it
> > discuss scope rule, it says there are four scopes for a variable:
> >
> > function scope
> > file scope
> > block scope
> > function-prototype scope
> >
> > I think(might be wrong):
> >
> > file scope: variables declared outside of any functions.[/color]
>
> Correct.
>[color=green]
> > block scope: variables declared inside a block such as a function. For
> > example:
> >
> > int f(int i, int j){
> > int k;
> > return 0;
> > }
> >
> > then the variable i, j and k are all block scope, right?[/color]
>
> Correct.
>[color=green]
> > function-prototype scope: The book said C ignores those. For example:
> >
> > int f(int x,int y);
> >
> > in this case, x and y are function-prototype scope?[/color]
>
> Correct. C does ignore these. You can have more than one prototype
> for the same function, as long as they all match the type of the
> function. Each one can give the parameters different names. And the
> actual definition of the function can use different names from any of
> the prototypes.
>
> The only use for parameter names in function prototypes is to provide
> useful hints to the programmer reading the prototype. Consider the
> difference between:
>
> void rectangle(int, int);
>
> ...and:
>
> void circle(int height, int width);
>[color=green]
> > function scope: This one I don't know. The book said only labels have
> > function scope and the 'switch' and 'goto' statements normally uses
> > those. For example:[/color]
>
> This is mixing up two things, and the result is incorrect. There are
> two types of labels:
>
> 1. Labels that can be the targets of a goto statement, of the form
> "some_legal_c_name:". These have function scope. You can "goto" a
> label from anywhere in the function that contains the label, even if
> the goto statement is before the label definition.
>
> 2. Labels that can only appear in a switch statement, namely
> "default:" and "case some_integer_constant_expression:". These labels
> do not have function scope, they are scoped to the switch block that
> contains them. A switch statement can only have one "default:" label,
> but there can be more than one switch statement in a function and each
> of them can have its own "default:". The same is true for the values
> of the expression in the case labels. The value of the expression in
> each case label within a single switch must all be different, but more
> than one switch in a single function can use the same case values.
>[color=green]
> > int h(int i){
> > again:
> > if(i == 0)
> > goto again;
> > }
> >
> > does 'again' have function scope? I am confuse. Can someone help me
> > out?[/color]
>
> Yes, again has function scope. But consider this:
>
> int h(int i)
> {
> switch (i)
> {
> case 1: do_something(); break;
> case 2: do_something_else(); break;
> default: break;
> }
>
> switch (i - 1)
> {
> case 1: do_nothing(); break;
> case 2: do_even_less(); break;
> default: break;
> }
> return i;
> }
>
> So you can see that each "case 1:", "case 2:", and "default:" label is
> scoped to its own switch.
>[color=green]
> > Also, What does static and extern use for? I know static can be used
> > to make the variable persist after function calls but what about
> > exter?
> >
> > Thanks![/color]
>
> Every identifier in a C program has four primary characteristics:
>
> 1. Scope, covered above.
>
> 2. Linkage.
>
> 3. Storage duration.
>
> 4. Name space.
>
> The static keyword is overloaded with two different uses related to
> both linkage and storage duration.
>
> The three types of linkage are external, internal, and none. Objects
> defined inside of any block have no linkage. Objects defined at file
> scope (variables and functions) have external linkage by default.
> That is, they may be accessed by name from code in other source code
> files compiled separately.
>
> If an object or function defined at file scope has the static keyword
> added to its definition, its linkage is changed from external to
> internal. Its name is not visible to other source files, and they
> cannot refer to it by name.
>
> So if you define the following at file scope:
>
> int x;
> int func(int param)
> {
> return x + param;
> }
>
> Then "x" and "func" have external linkage. Code in other source files
> can read or write "x" and call "func" so long as those other files
> have proper declarations of them.
>
> On the other hand, if you have this at file scope:
>
> static int x;
> static int func(int param)
> {
> return x + param;
> }
>
> Then "x" and "func" have internal linkage. They cannot be accessed or
> called by name from other source files. Other source files can have
> an object named "x" and a function named "func", and they will be
> different from these.
>
> Going back to the first example, where "x" and "func" have external
> linkage because they are defined without "static", they can be used by
> name from other source files, but only if those other source files
> know about them.
>
> If another source file wants to access "x", it needs a declaration
> like this:
>
> extern int x;
>
> This tells the compiler that "x" will exist somewhere else in the
> program, so this declaration does not define another "x", just allows
> this function the ability to access it when it is defined somewhere
> else.
>
> You can also use the "extern" keyword on function prototypes, but it
> is not really necessary because function prototypes, like function
> definitions, have external linkage by default.
>
> The third category is storage duration, and there are three types,
> static, automatic, and allocated.
>
> All objects defined at file scope have static storage duration. They
> exist and have an initial value before main() begins execution and
> continue to exist until the program ends.
>
> All objects defined at block scope with no storage class keyword, or
> with the keywords "auto" or "register" have automatic storage
> duration. They come into existence when execution enters their block.
> They go out of existence when execution leaves the block. If they are
> not specifically initialized when declared, they have indeterminate
> values.
>
> But objects defined within a block using the "static" keyword have
> static storage duration. Like file scope objects, they exist and have
> an initial value before main() starts and last for the entire program.
> They keep their current value even when execution leaves their block.
>
> The third storage duration, allocated, applies to memory obtained from
> malloc(), calloc(), or realloc(). It persists until it is free'd by
> another call to realloc() or free().
>[/color]
The structure/enum tags are not covered. Do they have namespace
or scope? What is the difference between these two, then?
Vijay
