Scope, lifetime and storage classes

Why it exists

Two questions sound similar but are different. Where in the source can I use this name? (scope) and how long does the thing it names exist while the program runs? (lifetime). A local variable is visible only inside its block and normally exists only while that block runs, so the two coincide and people forget they are separate. Storage classes such as static and extern pull them apart, and many GATE questions on this topic are about a variable whose scope and lifetime differ.

Prerequisites

Precise definitions

Scope is the part of the program text in which a name can be used. C has four kinds, two of which matter for GATE:

• Block scope. A name declared inside { ... } (including function parameters and the variable of a for header) is visible from just after its declarator to the end of that block.
• File scope. A name declared outside every function is visible from just after its declarator to the end of the translation unit (the source file after preprocessing).
• Function prototype scope (parameter names in a declaration) and function scope (labels) are rarely tested.

Shadowing. A name in an inner block hides the same name from an outer block (or from file scope) until the inner block ends. C uses static (lexical) scoping: which declaration a name refers to is decided by the program text, never by who called whom.

Lifetime (storage duration) is the part of the run during which the object exists.

• Automatic: created when execution enters the block, destroyed when it leaves. Default for locals. A fresh copy each time, holding garbage unless initialised.
• Static: exists for the whole run and is initialised once, to zero (or null pointers) unless you give a constant initialiser. Globals and static locals. (C11 also has thread duration, _Thread_local, which GATE does not need.)
• Allocated: from malloc to free (see the memory layout page).

Linkage says whether the same name in different scopes or files refers to the same object or function: external (shared, the default for file-scope functions and variables), internal (private to the file, static at file scope), or none (block-scope locals without extern, parameters, and names such as typedefs and labels).

Storage-class specifiers:

Initialisation rules.

• Objects with static duration (globals and static locals) are initialised once, before the program starts. The initialiser must be a constant expression (static int a = f(); is an error in C).
• Automatic objects are initialised each time the declaration is executed. Without an initialiser their value is indeterminate.

How it works

Step through three calls to the same function. Watch what disappears and what stays. The frame for counter holds the automatic a, which is created at 0 and vanishes on return. The globals and statics sit outside the stack in the data area and keep counting. Amber marks a value that has just changed.

The rule to remember: in the usual implementation, only automatic variables live in frames. static locals have the scope of a local but the lifetime of a global, which is exactly why they are tested.

Worked examples

#include <stdio.h>
 
int x = 1;
 
int main(void) {
    printf("%d ", x);
    {
        int x = 2;
        printf("%d ", x);
        {
            int x = 3;
            printf("%d ", x);
        }
        printf("%d ", x);
    }
    printf("%d\n", x);
    return 0;
}

1 2 3 2 1

#include <stdio.h>
 
int main(void) {
    for (int i = 0; i < 3; i++) {
        static int s = 0;
        int a = 0;
        s += 2;
        a += 2;
        printf("%d %d  ", s, a);
    }
    printf("\n");
    return 0;
}

2 2  4 2  6 2

#include <stdio.h>
 
int f(void) {
    static int n = 10;
    n += 5;
    return n;
}
 
int main(void) {
    int first = f();
    int second = f();
    printf("%d %d\n", first, second);
    return 0;
}

15 20

#include <stdio.h>
 
int i = 10;
 
void f(void) {
    int i = 5;
    i++;
    printf("%d ", i);
}
 
int main(void) {
    f();
    f();
    i++;
    printf("%d\n", i);
    return 0;
}

6 6 11

x = 1
procedure f()  { print x }
procedure g()  { local x = 2;  call f() }
call g()
call f()

Cheat box

Traps and GATE patterns

Connections

Where each kind of variable physically lives is on the memory layout page. A compiler implements these rules with a symbol table for scope and with activation records for automatic storage, and the way recursion keeps a fresh copy per call is explained in recursion and the call stack.

PYQs

Consider the following C program:
    #include <stdio.h>
    int r ( )
{
    static int num=7;
    return num--;
}
 int main ( )
{
 for (r ( ); r ( ); r ( ))
   printf ("%d", r ( ));
 return 0;
}
Which one of the following values will be displayed
on execution of the programs?

Consider the following three ANSI – C programs. P1,
P2, and P3

P1
P2
P3
#include
<stdio.h>

int a = 5;
int main(){
int a = 7;
return(0);
}
#include
<stdio.h>

int main(){
int a=5;
int a=7;
return(0);
}
#include
<stdio.h>

int main(){
int a=5;
float a=7;
return(0);
}

Which one of the following statement is true?

Consider the following program in C:

#include <stdio.h>

void func(int i, int j) {

if (i < j) {
       int i = 0;
       while (i < 10) {
           j += 2;

    i++

}
       }

  printf("%d", i);
}

int main() {

   int i = 9, j = 10;

func(i, j);

return 0;

}
The output of the program is ______. (answer in
integer)
Note: Assume that the program compiles and runs
successfully.

Consider the following C functions.

The return value of fun2(5) is ____

The output after executing the following program is
___

#include <stdio.h>

int total(int v) {
    while (v) {
        static int count += v & 1;
        v >>= 1;
    }
    return count;
}

void main() {
    static int x = 0;
    int i = 5;
    for (; i > 0; i--) {
        x = x + total(i);
    }
    printf("%d\n", x);
}

void count(int n){
    static int d = 1;
    printf("%d ", n);
    printf("%d ", d);
    d++;
    if(n > 1) count(n - 1);
    printf("%d ", d);
}

void main(){
    count(3);
}

Consider the following C program. The output of the
program is __________.
# include <stdio.h>
int f1(void);
int f2(void);
int f3(void);
int x = 10;
int main()
{
 int x = 1;
 x += f1() + f2() + f3() + f2();
printf("%d", x);
 return 0;
 }
int f1()
{
int x = 25;
 x++;
return x;
}
int f2( )
{
 static int x = 50;
 x++;
return x;
}
int f3( )
{
 x *= 10;
 return x;
}

Consider the following C code segment.
int a, b, c = 0;
void prtFun (void);
main ()
{
static int a = 1;
prtFun ();
a + = 1;
prtFun ();
printf("\n %d %d ", a, b);
}

void prtFun (void)
{
static int a = 2;
int b = 1;
a + = + + b;
printf (" \n %d %d ", a, b);
}
What output will be generated by the given code
segment?

Self-check

#include <stdio.h>
 
int count(void) {
    static int c = 0;
    return ++c;
}
 
int main(void) {
    int a = count();
    int b = count();
    int c = count();
    printf("%d %d %d\n", a, b, c);
    return 0;
}

1 2 3

#include <stdio.h>
 
int v = 1;
 
void bump(void) {
    int v = 5;
    v = v + 1;
}
 
int main(void) {
    bump();
    printf("%d\n", v);
    return 0;
}

1

Revision card

References