Static Storage Class Specifiers
Static variables are permanent variables within their own function or file. Unlike global variables, they are not known outside their function or file, but they maintain their values between calls. This feature makes them useful when you write generalized functions and function libraries that other programmers may use. static has different effects upon local variables and global variables.
Note:- By default static int a; will gave output 0. Without Initialize. Declaration can be multiple but Initialization can be once.
#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
#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.
Static local variables
When you apply the static modifier to a local variable, the compiler creates permanent storage for it, much as it creates storage for a global variable. The key difference between a static local variable and a global variable is that the static local variable remains known only to the block in which it is declared. In simple terms, a static local variable is a local variable that retains its value between function calls.
#include <stdio.h>
int series(void)
{
static int series_num;
series_num = series_num+23;
return series_num;
}
int main(){
series();// calling function
return 0;
}
#include <stdio.h>
int series(void)
{
static int series_num;
series_num = series_num+23;
return series_num;
}
int main(){
series();// calling function
return 0;
}
If I call one time it will primt 23, and if we I call once again it will print 23, 46. This is because static hold the value.
#include <stdio.h>
int series(void)
{
static int series_num=55;
series_num = series_num+3;
return series_num;
}
int main(){
series();// calling function
series();// calling function
return 0;
}
int series(void)
{
static int series_num=55;
series_num = series_num+3;
return series_num;
}
int main(){
series();// calling function
series();// calling function
return 0;
}
In The above code, series_num Initialize by 55. The output is: 58 61.
This is because of initialize value execute only once. After that compiler reject Initialize. Because Initialize is only once but assignment can multiple.
For example:
#include <stdio.h>
int main(){
static int i=10; //Initialization statement
int i=10; //Initialization statement,Compiler Error
i=25; //Assignment statement
printf("%d",i);
return 0;
}
Output: Compilation error
Static Global variables
Applying the specifier static to a global variable instructs the compiler to create a global variable that is known only to the file in which you declared it. This means that even though the variable is global, routines in other files may have no knowledge of it or alter its contents directly, keeping it free from side effects. For the few situations where a local static cannot do the job, you can create a small file that contains only the functions that need the global static variable, separately compile that file, and use it without fear of side effects.
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:
#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.
}
static variables enable you to hide portions of your program from other portions. This can be a tremendous advantage when you are trying to manage a very large and complex program
Static can also be applied to a function within a module. By default, functions are implicitly declared as extern. This means that if a function is defined within a c file and not prototyped within a header file, the compiler will still be able to link to the function (with perhaps a few warnings to the developer). In order to only make a function usable within a single module, the developer can place the static keyword before the function declaration. This will effectively hide the function from the external world and protect the use of that function and its variables
Comments
Post a Comment