Understanding Scope & Lifetime of Variables - onlinetutorialspoint

PROGRAMMINGJava ExamplesC Examples
Java Examples
C Examples
C Tutorials
aws
JAVAEXCEPTIONSCOLLECTIONSSWINGJDBC
EXCEPTIONS
COLLECTIONS
SWING
JDBC
JAVA 8
SPRING
SPRING BOOT
HIBERNATE
PYTHON
PHP
JQUERY
PROGRAMMINGJava ExamplesC Examples
Java Examples
C Examples
C Tutorials
aws
In this tutorial, we are going to learn about different storage classes, scope and lifetime of variables.
In C language, each variable has a storage class which decides scope and lifetime of that variable. The storage class of a variable determines whether the variable has a global or local scope and lifetime or A Storage Class defines the scope (visibility) and life-time of variables and/or functions within a ‘C‘ program.
All variables defined in a C program are allocated some physical location in memory where the variable’s value is stored. Memory and CPU registers are examples of memory locations where a variable’s value can be stored.
Storage classes provide the following information:
Where the variable would be stored.
What will be the initial value of the variable; i.e., the default value for the variable.
What is the scope of the variable; i.e., if the variable is accessible globally or is local to a function.
What is the life of the variable; i.e., how long would the variable exist in memory.
A keyword which specifies the storage class(auto, register, extern and static).
The scope determines the parts of a program in which a variable is available for use.
The lifetime refers to the period during which a variable retains a given value during execution of the program. It is also referred to as longevity.
There are four storage class specifiers in C language, they are:
auto
extern
static
register
The general form of a variable declaration that uses a storage class is:
storage_class_specifier data_type variable_name;
At most one storage_class_specifier may be given in a declaration. If no storage_class_specifier is specified then the following rules are used:
Variables declared inside a function are taken to be auto.
Variables declared outside a function are taken to be global.
Automatic variables are declared inside a block/function in which they are to be utilized.
These variables are created when a function is called and destroyed automatically when a function is exited.
Automatic variables are private to the function where they are declared. Because of this property, automatic variables are also referred to as local or internal variables.
A variable declared inside a function without any storage class specification is by default an automatic variable.
Auto variables can be only accessed within the block/function they have been declared and not outside them.
We seldom use the auto keyword in declarations because all block-scoped variables which are not explicitly declared with other storage classes are implicitly auto.
The format for specifying the automatic variables are:
auto data_type variable_1, variable_2,..., variable_n;
Some of the important points regarding auto variables are:
        Storage:	        CPU memory
	Initial value:	        undefined (can be any value)
	Keyword:		auto
	Scope:			local to the block in which it is defined
	Lifetime:		till control remains within the block in which 
                                it is defined
Consider the following code:
#include <stdio.h>
void main( ) {
  auto int i = 9;
  {
    auto int i = 99;
    {
      auto int i = 999;
      printf("Third inner block value = %d\n", i);
    }
    printf("Second inner block value = %d\n", i);
  }
  printf("First block value = %d\n", i);
}
Output:
Third inner block value = 999
Second inner block value = 99
First block value = 9

In the above code, you can see three definitions for variable i. Here, there will be no error and the program will compile and execute successfully.
When the code executes, first the printf in the innermost block will print 999 and the variable i defined in the innermost block will no longer be visible as soon as control exits from the block.
Later, the control enters into the second outer block and prints 99 and later the control enters into the outermost block and prints 9.
Note: automatic variables must always be initialized properly, otherwise you are likely to get unexpected results because automatic variables are not given an initial value by default.
Variables that are declared outside a function are by default global variables. Unlike the local variables, global variables are visible in all functions in that program. Any function can use and also change its value.
Let us consider the below example:
void main() {
  int y = 4;
  y = y + x; // Compiler flags this as an error
  ...
}
int x = 5;
void function1() {
  x = x + 10;
  printf ("%d", x);
}
Even though the variable declaration int x; outside the main() function is a valid global declaration, since the compiler scans from the top of the file, when it reaches the statement y = y + x;, it raises an error saying the variable x is not declared before its usage.
One solution is to move the declaration int x; above the main() function. The second solution is to declare the variable before it is used inside the main method with the keyword extern, as extern int x;.
The extern keyword used before the variable informs the compiler that this variable is declared somewhere else globally and that it has to refer to it. The extern declaration does not allocate storage space for variables because it is only trying to refer to the already declared global variable.
For this reason, we cannot initialize the variable in the extern declaration. A normal global variable can be made extern when it is being used much before its declaration.
The format for specifying the external variables is
extern data_type variable_1, variable_2,..., variable_n;

Some of the important points regarding extern variables are:
	Storage:		Memory
	Initial value:	        zero (0)
	Keyword:		extern
	Scope:			entire program
	Lifetime:		throughout the program execution

Auto variables are stored in memory. CPU also has a small storage area called registers which are used for quick storage and retrieval. In C, we can suggest the compiler store certain variables in the CPU registers by specifying them with the storage class register. Apart from their physical storage location, register variables follow the same rules of scope as automatic variables.
The syntax for declaring register variables is
register data_type variable_1;
There may be some special cases when we want some frequently accessed variables to be stored in registers to increase the performance of the program. In such cases, we use the register storage class while declaring the variable.
It should be noted that there is no guarantee that these variables will always be stored in registers. When there isn’t enough space in registers, they will be stored in the memory along with other auto variables.
Care should be taken that we do not specify too many variables as register variables, as it may even degrade the performance. If there are too many, the CPU might end up spending too much time moving data back and forth between registers and temporary storage area, if there are not enough registers to hold all such variables.
Ideally, registers should be used only when one has good knowledge of the compiler and computer architecture being used.
A few points regarding register variables are given below:
	Storage:		CPU registers
	Initial value:	        garbage value
	Keyword:		register
	Scope:			local to the block in which it is defined
	Lifetime:		till control remains within the block in which
                                it is defined

A variable can be declared as a static variable by using the keyword static. Auto variables are created each time they are initialized in a block and are destroyed when they go out of scope. However, static variables are initialized only once and they remain in existence till the end of the program.
A static variable can either be local (to a function) or global. The format for specifying static variables is
static data_type variable_1, variable_2,..., variable_n;
The static variables which are declared inside a function are stored in the statically allocated memory and remain alive throughout the execution of the program, but remember that their scope remains local to the function. The main difference between auto and static is that the static variables do not disappear when the function is no longer active (in scope) and their values persist across multiple calls of the same function.
Some of the important points regarding static variables are:
	Storage:		Memory
	Initial value:	        zero (0)
	Keyword:		static
	Scope:			local to the block in which it is defined
	Lifetime:		throughout the program execution
Wiki – Scope
C- Variables and Keywords
Happy Learning 🙂

PHP Variables Example Tutorials
Variables & Keywords in C Language
Dynamic Memory Allocation in C
Understanding the structure of a C Program
User defined Functions in C
C – Derived and User Defined Data Types
Functions in C
C – One Dimensional Arrays
Java Static Variable Method Block Class Example
Java variable types Example
C Multi Dimensional Arrays
PHP Functions Example Tutorials
Try with Resources Example in Java
C – Integer Data Types – int, short int, long int and char
PHP Superglobals Example Tutorials

PHP Variables Example Tutorials
Variables & Keywords in C Language
Dynamic Memory Allocation in C
Understanding the structure of a C Program
User defined Functions in C
C – Derived and User Defined Data Types
Functions in C
C – One Dimensional Arrays
Java Static Variable Method Block Class Example
Java variable types Example
C Multi Dimensional Arrays
PHP Functions Example Tutorials
Try with Resources Example in Java
C – Integer Data Types – int, short int, long int and char
PHP Superglobals Example Tutorials
 


Δ
 C – Introduction
 C – Features
 C – Variables & Keywords
 C – Program Structure
 C – Comment Lines  & Tokens
 C – Number System
 C – Local and Global Variables
 C – Scope & Lifetime of Variables
 C – Data Types
 C – Integer Data Types
 C – Floating Data Types
 C – Derived, Defined Data Types
 C – Type Conversions
 C – Arithmetic Operators
 C – Bitwise Operators
 C – Logical Operators
 C –  Comma and sizeof Operators
 C – Operator Precedence and Associativity
 C – Relational Operators
 C Flow Control – if, if-else, nested if-else, if-else-if
 C – Switch Case
 C Iterative – for, while, dowhile loops
 C Unconditional – break, continue, goto statements
 C – Expressions and Statements
 C – Header Files & Preprocessor Directives
 C – One Dimensional Arrays
 C – Multi Dimensional Arrays
 C – Pointers Basics
 C – Pointers with Arrays
 C – Functions
 C – How to Pass Arrays to Functions
 C – Categories of Functions
 C – User defined Functions
 C – Formal and Actual Arguments
 C – Recursion functions
 C – Structures Part -1
 C – Structures Part -2
 C – Unions
 C – File Handling
 C – File Operations
 C – Dynamic Memory Allocation
 C Program – Fibonacci Series
 C Program – Prime or Not
 C Program – Factorial of Number
 C Program – Even or Odd
 C Program – Sum of digits till Single Digit
 C Program – Sum of digits
 C Program – Reverse of a number
 C Program – Armstrong Numbers
 C Program – Print prime Numbers
 C Program – GCD of two Numbers
 C Program – Number Palindrome or Not
 C Program – Find Largest and Smallest number in an Array
 C Program – Add elements of an Array
 C Program – Addition of Matrices
 C Program – Multiplication of Matrices
 C Program – Reverse of an Array
 C Program – Bubble Sort
 C Program – Add and Sub without using + –