Scope rules of the "persistent" variables in C

Order of discussion of scoping in this and the next webpage

The following things will be covered in this webpage:

Difference between defining a variable and declaring a variable
Scope of persistent variables

Scope of parameter and local variables

C has a more complex set of scoping rules for parameter and local variables than Java
(Actually, Gosling has made the scoping rules simpler by forbidding user to define multiple parameter/local variables with the same name inside a method).
This topic will be discussed in anther webpage: click here

The scope of Global variables in C

Scope of Global variables in C:

Although global variables exist from the start to the end of the execution of a program, they are not automatically accessible
A global variable is accessible:

Example that shows the scope of global variables:

void f1() /* Function f1() that uses global var x */ { x = 4; /* ******** Access error !!!! ********* */ } int x; /* Definition of global var x */ void f2() /* Function f2() that uses global var x */ { x = 4; }

Example Program: (Demo above code)

Prog file: click here

How to run the program:

Right click on link and save in a scratch directory
To compile: gcc -c global1.c

Result:

global1.c: In function 'f1': global1.c:(line) 5: error: 'x' undeclared (first use in this function)

Defining and declaration of a variable

Important fact of programming lanugaes

Defining a variable:

Syntax to define a variable in C:

Examples:

int x; double y;

When a definition of a variable is processed, the C compiler will:

Declaring a variable:

Syntax to declare a variable in C:

extern DataType Varname ;

Examples:

extern int x; extern double y;

In a declaration of a variable, the C compiler will only:

In other words:

A declaration of a variable is an announcement of the (data) type of a variable that has been defined elsewhere.

Why/When to use declarations:

An obvious fact:
Therefore:

Fact:

A global variable that is used by a C program file "file1.c" may be defined inside another C program file "file2.c"
In order for the C compiler to use the correct encoding method to interpret the bits stored in a variable, it must know the data type

How do you solve this problem (without defining (= reserving memory space) a variable multiple times) ???

To inform C compiler which encoding method to use (i.e., the data type), we must therefore:

Tell the C compiler the data type of a variable...
In other words:

Example: this C program will not compile

We can fix this problem by using a declaration of the variable x:

extern int x; /* ******** Declaration of x ********** */ void f1() /* Function f1() that uses global var x */ { x = 4; /* ******** Access error !!!! ********* */ } int x; /* Definition of global var x */ void f2() /* Function f2() that uses global var x */ { x = 4; }

Example Program: (Demo above code)
- Prog file: click here
How to run the program:

Reminder: Shadowing a variable

Reminder: shadowing a class variable in Java (See: CS170 material on "Shadowing" )

When a method has a local variable or a parameter variable defined in a scope whose name is equal to the name of a class variable, then:

Shadowing global variables in C

Shadowing a global variable in C:

When a function has a local variable or a parameter variable defined in a scope whose name is equal to the name of a global variable, then:

Example:

Explanation:

When double r; is processed, the scope of the global variable r begins.
The statement:
will use the global variable double r
When the C compiler processes the definition of the local variable:
the global variable double r is shadowed
The statement
will use the local variable int r

Experiment with a C program:

double r = 3.14; int main( int argc, char* argv[] ) { printf( "r = %lf\n", r ); /* Uses "double r" */ int r = 4444; /* Shadows global variable double r ! */ printf( "r = %d\n", r ); /* Uses "int r" */ printf( "r = %lf (this will print weird stuff)\n", r ); }

Example Program: (Demo above code)
- Prog file: click here
How to run the program:

Static global variables

Static global variable:

A static global variable is a global variable that can only be accessed by functions in the same C program file as the variable.
Implementation:

Example:

File 1: global4a.c	File 2: global4b.c
#include <stdio.h> extern double x; extern void func(); int main( int argc, char* argv[] ) { func(); printf( "x = %lf\n", x ); /* Try to uses "static double x" */ }	*#include <stdio.h> static double x; void func() { x = 12345; printf( "x = %lf\n", x ); / uses "static double x" / }*

File 1: global4a.c

File 2: global4b.c

  #include <stdio.h>
  
  extern double x;
   
  extern void func();
   
  int main( int argc, char* argv[] )
  {
     func();
     printf( "x = %lf\n", x );    
       /* Try to uses "static double x" */    
  }

#include <stdio.h> static double x; void func() { x = 12345; printf( "x = %lf\n", x ); /* uses "static double x" */ }

When you compile these programs, you will get an error:

UNIX>> gcc -c global4a.c // No error UNIX>> gcc -c global4b.c // No error UNIX>> gcc global4a.o global4b.o // Error in linking loader phase Undefined first referenced symbol in file x global4a.o ld: fatal: Symbol referencing errors. No output written to a.out collect2: ld returned 1 exit status

Explanation:

The static global variable x can only be access within File 2.
The main() function is not stored in the same file !

Note: try this

Remove the keyword static from the variable x
Re-compile --- no error !!!

Example Program: (Demo above code)
- The global4a.c Prog file: click here
- The global4b.c Prog file: click here
How to run the program:

Static local variable

Static local variable:

A static local variable is created at the start of the program (just like the global variables)
The only difference is this kind of variables has a local scope:

Final note....

In Java, a local variable or a parameter variable can shadow a class variable:

public class demo { public static double x = 3.14; // Class variable public static void main( String[] args ) { int x = 4; // Shadows class variable x System.out.println(x); // Prints 4 } }

In Java, you can still access the "shadowed" class variable using the qualified name:

public class demo { public static double x = 3.14; // Class variable public static void main( String[] args ) { int x = 4; // Shadows class variable x System.out.println(demo.x); // Prints 3.14 } }

Warning: