Lecture 11 : Local, Global and Static variable monolithic vs modular programming, Storage classes, storage class cont.., pointer in C programming language

Lecture : 11

Local, Global and Static variable 

Local variable:-  Variables that are defined with in a body of function or block. The local variables can be used only in that function or block in which they are declared. 

Same variables may be used in different functions such as 

function()

{

int a,b; function 1();

}

function2 ()

{

int a=0; b=20;

}

Global variable:-  the variables that are defined outside of the function is called global variable. All functions in the program can access and modify global variables. Global variables are automatically initialized at the time of initialization. 

Example:

#include<stdio.h> 

void function(void); 

void function1(void); 

void function2(void); 

int a, b=20;

void main()

{

printf(“inside main a=%d,b=%d \n”,a,b); function();

function1(); function2();

}

function()

{

Prinf(“inside function a=%d,b=%d\n”,a,b);

}

function 1()

{

prinf(“inside function a=%d,b=%d\n”,a,b);

}

function 2()

{

prinf(“inside function a=%d,b=%d\n”,a,);

}

Static variables:- static variables are declared by writing the key word static.

syntax:-

static data type variable name; 

static int a;

• the static variables initialized only once and it retain between the function call. If its variable is not initialized, then it is automatically initialized to zero. 

Example:

void fun1(void); 

void fun2(void); 

void main()

{

fun1();

fun2();

}

void fun1()

{

int a=10, static int b=2; printf(“a=%d, b=%d”,a,b); a++;

b++;

}

Output: 

a= 10 b= 2

a=10 b= 3

Recursion

When function calls itself (inside function body) again and again then it is called as recursive function. In recursion calling function and called function are same. It is powerful technique of writing complicated algorithm in easiest way. According to recursion problem is defined in term of itself. Here statement with in body of the function calls the same function and same times it is called as circular definition. In other words recursion is the process of defining something in form of itself.

Syntax:

main ()

{

rec();   /*function call*/ 

rec();

rec();

Example:-

/*calculate factorial of a no.using recursion*/ 

int fact(int); 

void main()

{

int num;

printf(“enter a number”); scanf(“%d”,&num); f=fact(num); printf(“factorial is =%d\n”f);

}

fact (int num)

{

If (num==0||num==1)

return 1; else

return(num*fact(num-1));

}

Monolithic Programming

The program which contains a single function for the large program is called monolithic program. In monolithic program not divided the program, it is huge long pieces of code that jump back and forth doing all the tasks like single thread of execution, the program requires.Problem arise in monolithic program is that, when the program size increases it leads inconvenience and difficult to maintain

such as testing, debugging etc. Many disadvantages of monolithic programming are:

1. Difficult to check error on large programs size.

2. Difficult to maintain because of huge size.

3. Code can be specific to a particular problem. i.e. it cannot be reused.

Many early languages (FORTRAN, COBOL, BASIC, C) required one huge workspace with labelled areas that may does specific tasks but are not isolated.

Modular Programming

The process of subdividing a computer program into separate sub-programs such as functions and subroutines is called Modular programming. Modular programming sometimes also called as structured programming. It enables multiple programmers to divide up the large program and debug pieces of program independently and tested.

Then the linker will link all these modules to form the complete program. This principle dividing software up into parts, or modules, where a module can be changed, replaced, or removed, with minimal effect on the other software it works with.

Segmenting the program into modules clearly defined functions, it can determine the source of program errors more easily. Breaking down program functions into modules, where each of which accomplishes one function and contains all the source code and variables needed to accomplish that function.

Modular program is the solution to the problem of very large program that are difficult to debug, test and maintain. A program module may be rewritten while its inputs and outputs remain the same. The person making a change may only understand a small portion of the original program.

Object-oriented programming (OOP) is compatible with the modular programming concept to a large extent.

• Less code has to be written that makes shorter.
• A single procedure can be developed for reuse, eliminating the need to retype the code many times.
• Programs can be designed more easily because a small team deals with only a small part of the entire code.
• Modular programming allows many programmers to collaborate on the same application.
• The code is stored across multiple files.
• Code is short, simple and easy to understand and modify, make simple to figure out how the program is operate and reduce likely hood of bugs.
• Errors can easily be identified, as they are localized to a subroutine or function or isolated to specific module.
• The same code can be reused in many applications.
• The scoping of variables and functions can easily be controlled.

Disadvantages

However it may takes longer to develop the program using this technique

Storage Classes

Storage class in c language is a specifier which tells the compiler where and how to store variables, its initial value and scope of the variables in a program. Or attributes of variable is known as storage class or in compiler point of view a variable identify some physical location within a computer where its string of bits value can be stored is known as storage class.

The kind of location in the computer, where value can be stored is either in the memory or in the register. There are various storage class which determined, in which of the two location value would be stored.

Syntax of declaring storage classes is:-

storageclass   datatype    variable name; 

There are four types of storage classes and all are keywords:- 

1 ) Automatic (auto)

2 ) Register (register)

3) Static (static)

4 ) External (extern)

Examples:-

auto float x; or float x; 

extern int x; 

register char c; 

static int y;

Compiler assume different storage class based on:-

1 ) Storage class:- tells us about storage place(where variable would be stored).

2) Intial value:- what would be the initial value of the variable.

• If initial value not assigned, then what value taken by uninitialized variable.

3) Scope of the variable:-what would be the value of the variable of the program.

4) Life time :- It is the time between the creation and distribution of a variable or how long would variable exists.

1. Automatic storage class

The keyword used to declare automatic storage class is auto. Its features:-

Storage-memory location

Default initial value:-unpredictable value or garbage value.

Scope:-local to the block or function in which variable is defined.

Life time:-Till the control remains within function or block in which it is defined. It terminates when function is released.

The variable without any storage class specifier is called automatic variable. 

Example:-

main( )

{

auto int i; printf(“i=”,i);

}

2. Register storage class

The keyword used to declare this storage class is register. The features are:-

Storage:-CPU register.

Default initial value :-garbage value

Scope :- local to the function or block in which it is defined.

Life time :- till controls remains within function or blocks in which it is defined.

• Register variable don’t have memory address so we can’t apply address operator on it. CPU register generally of 16 bits or 2 bytes. So we can apply storage classes only for integers, characters, pointer type.
• Variable stored in register storage class always access faster than,which is always stored in the memory. But to store all variable in the CPU register is not possible because of limitation of the register pair.
• And when variable is used at many places like loop counter, then it is better to declare it as register class.

Example:- 

main( )

{

register int i; for(i=1;i<=12;i++) printf(“%d”,i);

}

3. Static storage class

The keyword used to declare static storage class is static. Its feature are:-

Storage:-memory location

Default initial value:- zero

Scope :- local to the block or function in which it is defined.

Life time:- value of the variable persist or remain between different function call. Example:-

main( )

{

reduce( );

reduce( );

reduce ( );

}

reduce( )

{

static int x=10; printf(“%d”,x); x++;

}

Output:-

10,11,12

External storage classes

The keyword used for this class is extern. Features are:-

Storage:- memory area 

Default initial value:-zero 

Scope :- global

Life time:-as long as program execution remains it retains.

• Declaration does not create variables, only it refer that already been created at somewhere else. So, memory is not allocated at a time of declaration and the external variables are declared at outside of all the function.

Example:-

int i,j;

void main( )

{

printf( “i=%d”,i ); receive( ); receive ( ); reduce( );

reduce( );

}

receive( )

{

i=i+2;

printf(“on increase i=%d”,i);

}

reduce( )

{

i=i-1;

printf(“on reduce i=%d”,i);

}

Output:-

i=0,2,4,3,2.

When there is large program i.e divided into several files, then external variable should be preferred. External variable extend the scope of variable.

Thank you 

For complete course click here