Keyword
static is used for declaring static variables in c. This modifier is used with
all data types like int, float, double, array, pointer, structure, function etc.
Important
points about static keyword:
1.
It is not default
storage class of global variables. For example, analyze the following three
programs and its output.
(a)
#include<stdio.h>
int a;
int main(){
printf("%d",a);
return 0;
}
Output:
0
(b)
#include<stdio.h>
static int a;
int main(){
printf("%d",a);
return 0;
}
Output:
0
(c)
#include<stdio.h>
extern int a;
int main(){
printf("%d",a);
return 0;
}
Output:
Compilation error
At
first glance if you will observe the output of above three codes you can say
default storage class of global variable is static. But it is not true. Why?
Read extern storage class.
2.
Default initial value of static integral type variables are zero otherwise
null. For example:
#include <stdio.h>
static char c;
static int i;
static float f;
static char *str;
int main(){
printf("%d %d %f
%s",c,i,f,str);
return 0;
}
Output:
0 0 0.000000 (null)
3.
A same static variable can be declared many times but we can initialize at only
one time. For example:
(a)
#include <stdio.h>
static int i; //Declaring the variable i.
static int i=25; //Initializing the variable.
static int i; //Again declaring the variable i.
int main(){
static int i; //Again declaring the variable i.
printf("%d",i);
return 0;
}
Output:
25
(b)
#include <stdio.h>
static int i; //Declaring the variable
static int i=25; //Initializing the variable
int main(){
printf("%d",i);
return 0;
}
static int i=20; //Again initializing the variable
Output: Compilation
error: Multiple initialization variable i.
4.
We cannot write any assignment statement globally. For example:
#include <stdio.h>
static int i=10; //Initialization statement
i=25; //Assignment statement
int main(){
printf("%d",i);
return 0;
}
Output:
Compilation error
Note: Assigning any value to the
variable at the time of declaration is known as initialization while assigning
any value to variable not at the time of declaration is known assignment.
(b)
#include <stdio.h>
static int i=10;
int main(){
i=25; //Assignment statement
printf("%d",i);
return 0;
}
Output:
25
(5)
A static variable initializes only one time in whole program. For example:
#include <stdio.h>
static int i=10;
int main(){
i=5;
for(i=0;i<5;i++){
static int a=10; //This statement will execute
//only time.
printf("%d",a++);//This statement will
execute
//five times.
}
return 0;
}
Output:
10 11 12 13 14
(6)If
we declared static variable locally then its visibility will within a block
where it has declared. For example:
#include<stdio.h>
int main(){
{
static int a=5;
printf("%d",a);
}
//printf("%d",a); variable a is not
visible here.
return 0;
}
Output:
5
7.
If declared a static variable or function globally then its visibility will
only the file in which it has declared not in the other files. For example:
(a)
#include<stdio.h>
static float a=144.0f; //global
to all function
int main(){
{
printf("%d",a); //variable a is
visible here.
//printf("%d",b);
variable b is not visible here.
}
printf("%d",a); //variable
a is visible here.
//printf("%d",b); variable b is not
visible here.
return 0;
}
static int b=5; //Global to only calculation function
void calculation(){
printf("%d",a); //variable
a is visible here.
printf("%d",b); //variable
b is visible here.
}
(b)
Consider a c program which has written in two files named as one.c and two.c:
//one.c
#include<conio.h>
static int i=25;
static int j=5;
int main(){
sum();
return 0;
}
//two.c
#include<stdio.h>
extern int i; //Declaration of variable i.
extern int j; //Declaration of variable j.
/**
Above two lines will
search the initialization statement of variable i and j either in two.c (if
initialized variable is static or extern) or one.c (if initialized variable is
extern)
*/
extern void sum(){
int s;
s=i+j;
printf("%d",s);
}
Compile
and execute above two file one.c and two.c at the same time:
In Turbo c compiler
Step
1: Write above two codes in the file named as one.c and two.c (You can give any
name as you like) and save it.
Step
2: In Turbo c++ IDE click on Project
-> Open project menu as shown in following screen dump:
Step
3: After Clicking on open project you will get following screen:
In
Open project File text field write any project name with .prj extension. In
this example I am writing project name as CProject.PRJ. Now press OK button.
Step
4: After pressing OK button you will get following screen:
Now
click on Project -> Add item menu.
Step
5: After clicking Add item you will get following screen:
In
the name text field write down all c source code file one by one i.e. first
write one.c and click on Add button.
Then write two.c and click on Add button and so on
Step
6: At the end click on Done button.
After clicking on done button you will get following screen:
At
the lower part of window you can see project name, list of files you have added
etc.
Step7:
To compile the two files press Alt+F9 and
to run the above program press Ctrl+F9
Note:
To close the project click on Project
-> Close project.
Output:
Compilation error: Unknown symbol i and j.
Hence
we can say variable i and j which has initialized into two.c is not visible in
file one.c. This example proves visibility of globally declared static variable
is file.
Note: In the above
example function sum which was declared and defined in two.c has also storage
class extern. So we can call from other file (one.c).If it will static then we
cannot call function sum since static storage class is only visible to the file
where it has declared.
(8)If
we static variable has declared locally or globally its scope will always whole
the program. For example:
(a)
//locally declaration of static variable
#include<stdio.h>
void visit();
int main(){
int i=0;
{ //Opening inner block
static int a=5; //locally declaration
XYZ:; //Label of goto statement
printf("%d ",a);
a++;
i++;
} //closing inner block.
visit();
/* printf("%d",a); Variable a is not visible here but
it
is alive. */
if(i<5)
goto XYZ;
return 0;
}
void visit(){
}
Output:
5 6 7 8 9
Explanation:
When program control will come out of inner block where variable a has declared
then outside of inner block variable a is not visible but its scope is outside
the program i.e. variable a hasn't dead .If with help of goto statement control
again comes inside the inner block it prints previous incremented values which
was not possible in case of auto or register variables.
(b)
//Locally
declarations of variable
There
are two c source code files:
//one.c
#include<stdio.h>
#include<conio.h>
void main(){
int i;
for(i=0;i<3;i++){
{
static int a=5;
printf("%d\n",a);
a++;
}
visit();
}
getch();
}
//two.c
#include<stdio.h>
void visit(){
printf("Don’t disturb, I
am learning storage class");
/* printf("%d",a); Variable a is not visible here but
It
is alive. */
}
Now
compile and execute both files together:
Output:
5
disturb,
I am learning storage class
6
disturb,
I am learning storage class
7
disturb,
I am learning storage class
Explanation:
When control goes to another file and comes even that variable didn’t dead and
it prints previous incremented value.
Note: In
both examples if you will declare static variable globally you will get same
output.
9.
A static variables or functions have internal linkage. An internal linkage
variables or functions are visible to the file where it has declared.
8 comments:
good for practice,thanks for posting
its goog
Really good one
Good collection..
In question 11, example 3(a) ans should be 0.
Good question thank you
Very good.
very good describe about negative integers
Post a Comment