In this article, we will learn about local, static, and global variables in C with simple examples. These variables are often discussed together because their behavior can be confusing, especially when we use the static and extern keywords.
To understand them properly, we first need to understand four important concepts:
Scope: Where can we use the variable’s name?
Linkage: Can the same name refer to the same object in another scope or translation unit?
Storage duration: How long does the object exist?
Initialization: What value does the object have when it starts its lifetime?
Once these concepts are clear, the behavior of local, static, and global variables becomes much easier to understand.
What is a Variable in C?
A variable provides a name that we can use to access an object that stores a value.
For example:
int age = 35;
Here, age is the identifier (name) used to refer to an object of type int. The object stores the value 35.
The behavior of an object depends not only on its type, but also on where and how it is declared. Its declaration determines important properties such as its scope, linkage, storage duration, and initialization.
Understanding these properties is essential for understanding local, static, and global variables in C.
Local Variable in C:
The local variable is a variable that is declared within a function, block (within curly braces), or function argument. Consider the below program,
void test(int x, int y)
{
int a;
}
In the above program, a, x and y are local variables. They only accessible within the test function when control comes out from the function then they will destroy automatically.
If you will create a variable within the function and create the same name variable within the block (inside curly braces) in the same function, then both variables would be different. As soon as the block ends (curly braces) the variable which declared inside the block is destroyed. See the below code,
#include <stdio.h>
int main(int argc, char *argv[])
{
int a = 5;
{
int a = 10;
printf("value of a = %d\n",a);
}
printf("value of a = %d\n",a);
return 0;
}
Output:
Some important points related to the local variable
1. The stack contains non-static local variables from functions and related book-keeping data.
2. As soon as the block ends (curly braces) the variable which declared inside the block is destroyed and it will not visible to the outside of the block. See the below code, when you will compile the below code then you will get the error.
#include <stdio.h>
int main(int argc, char *argv[])
{
{
int a = 10;
}
printf("value of a = %d\n",a);
return 0;
}
3. If you will not mention storage class with a local variable, then the auto storage class will attach with a local variable.
4. Never return the address of the local variable from the function. It will be the cause of the dangling pointer.
Let see the below programming example,
In the below code, Data (variable) is destroyed when control comes outside the function. So if you try to read the value of Data using the pointer after calling the Fun() you will get an undefined result.
So in the below code piData is a dangling pointer that is pointing a memory that is not available.
#include<stdio.h>
int* Fun()
{
int Data = 5; //Local variable
return &Data; //Address of local variable
}
int main()
{
//Returning address of the local variable
int *piData = Fun();
printf("%d", *piData);
return 0;
}
Note: None linkage is associated with the local variable.
Static Variable in C
A static variable preserves its previous value and it is initialized at compilation time when memory is allocated. If we do not initialize the static variable, then it’s the responsibility of the compiler to initialize it with zero value.
Syntax: static Data_type Variable_name;
Let see the below program, in which I have created static variables.
#include <stdio.h>
// Uninitialized global variable stored in BSS
static int data1;
//Initialized static variable stored in DS
static int data2 = 0;
int main(void)
{
// Uninitialized static variable stored in BSS
static int data3;
//Initialized static variable stored in DS
static int data4 = 0;
//Printing the value
printf("data1 = %d\n",data1);
printf("data2 = %d\n",data2);
printf("data3 = %d\n",data3);
printf("data4 = %d\n",data4);
return 0;
}
Output:
data1 = 0
data2 = 0
data3 = 0
data4 = 0
Some important points related to the static variable
1. If we have used the static keyword with a variable or function, then only internal or none linkage is worked.
2. A static variable lives throughout the program but there is scope in the module in which it has been declared. See the below program in which I have created a local static variable data1. The life of data1 is throughout the program but it will visible only test function.
#include <stdio.h>
void test()
{
//Initialized static variable stored in DS
static int data1 = 0;
printf("%d\n",data1);
}
int main()
{
test();
return 0;
}
3. A global variable with static keyword has internal linkage, so it only accesses within the translation unit (.c). It is not accessible by another translation unit. The static keyword protects your variable to access from another translation unit.
4. Static variables are initialized as 0 if not initialized explicitly.
5. Initialized static variable creates in DS and uninitialized static variable creates in BSS.
6. By default in C language, the linkage of the function is external that it means it is accessible by the same or another translation unit. With the help of the static keyword, we can make the scope of the function local, it only accesses by the translation unit within it is declared.
7. A static variable only initializes once, so a variable declared static within the body of a function maintains its prior value between function invocations.
In the below program, you can see the value of data persist between the different function call.
#include<stdio.h>
int test()
{
static int data = 0;
data++;
return data;
}
int main()
{
printf("data = %d\n", test());
printf("data = %d\n", test());
printf("data = %d\n", test());
return 0;
}
Output:
Global Variable in C
Variables which declared outside the function are called global variables. A global variable is not limited to any function or file it can be accessed by any function or outside of the file. If you have not initialized the global variables, then it automatically initialized to 0 at the time of declaration.
See the below program, the data variable is a global variable.
#include<stdio.h>
int data; // global variable
int main()
{
printf("data = %d\n", data);
return 0;
}
Output:
data = 0
Some important points related to the global variable
1. Unlike local variables, global variables are not destroyed as soon as the function ends.
2. Global variables are initialized as 0 if not initialized explicitly.
3. Initialized global variable creates in DS and uninitialized global variable creates in BSS.
4. By default, all global variable has external linkage.
Suppose in a program there are two files Driver.c and Calculation.c. Now the requirement is to share an identifier between these two files to get the result. I have written down a sample code to describe the importance of the global variable.
Driver.c
#include <stdio.h>
int Amount = 0; //External Linkage
int main()
{
Addition(); //function define in other file.
printf("%d\n", Amount); //Display amount
return 0;
}
Calculation.c
extern int Amount;
void Addition()
{
int a = 0, b = 0;
printf("Enter the value\n");
scanf("%d%d",&a,&b);
Amount = a + b;
}
For more detail see this article, Importance of the linkage.
Some important program related to the variable which asks by your interviewer:
Q1:
#include <stdio.h>
int main()
{
printf(" Data = %d \n", data);
return 0;
}
Answer:?
Q2:
#include <stdio.h>
int main()
{
int data = 6;
int data = 27;
printf("Data %d\n", data);
return 0;
}
Answer:?
Q3:
#include <stdio.h>
int main()
{
int main = 6;
printf("%d", main);
return 0;
}
Answer:?
Q4:
#include<stdio.h>
int main()
{
extern int data;
data = 1993;
printf("%d",data);
return 0;
}
Answer:?
Q5:
#include <stdio.h>
int main()
{
int data = 30;
{
int data = 10;
printf("%d",data);
}
return 0;
}
Answer:?
Q6:
#include<stdio.h>
int main()
{
{
int a = 10;
}
printf("value of a = %d\n",a);
return 0;
}
Answer:?
Q7:
#include<stdio.h>
int main(void)
{
extern int var;
var = 10;
printf("%d",var);
return 0;
}
int var = 0;
Answer:?
Q8:
#include<stdio.h>
int main(void)
{
extern int var;
printf("%d",var);
int var = 0;
return 0;
}
Answer:?
Q9:
#include<stdio.h>
int init()
{
return 10;
}
int main()
{
static int data = init();
printf(" value of data = %d", data);
return 0;
}
Answer:?
Q10:
#include<stdio.h>
int main()
{
static int data;
printf("%d \n", data);
return 0;
}
Answer:?
Q11:
#include<stdio.h>
int test()
{
int data = 0;
data++;
return data;
}
int main()
{
printf("data = %d\n", test());
printf("data = %d\n", test());
return 0;
}
Answer:?
Q12:
#include<stdio.h>
int test()
{
static int data = 0;
data++;
return data;
}
int main()
{
printf("data = %d\n", test());
printf("data = %d\n", test());
return 0;
}
Answer:?
Q13:
#include <stdio.h>
int main(void)
{
int * piData;
{
//block
int Data = 27;
piData = &Data;
}
printf("piData = %d\n", *piData);
return 0;
}
Answer: ?
Q14:
#include<stdio.h>
int *Fun()
{
int Data = 5; //Local variable
return &Data; //Address of local variable
}
int main()
{
//Returning address of the local variable
int *piData = Fun();
printf("%d", *piData);
return 0;
}
Answer: ?
Q15:
Can we access a global variable if there is a local variable with the same name in C?
Answer: ?
Q16:
Can we Redeclare the global variable twice in C?
Answer: ?
Q17:
Can Global Variables be dangerous and we should avoid it?
Answer: ?
Q18:
How linkers resolve global symbols define at multiple places in C application?
Answer: ?
Q19:
What is the difference between static variables and register variables in C?
Answer: ?
Q20:
What are the default values of static variables in C?
Answer: ?
Q21:
How are variables scoped in C – Static or Dynamic?
Answer: ?
Q22:
What is the difference between the internal static variable and the external static variable in C?
Answer: ?
Q23:
Can we use extern and static keywords together?
Answer: ?
Don’t forget to write your answer in the comment box.
Recommended Articles for you:
- Introduction of internal, external and none linkage in C
- Memory Layout of C program
- Use of typedef in C
- C macro, you should know
- typedef vs #define in c, you should know
- Use of enum in C programming
- The character set of C Language
- Format specifiers in C
- Data types in C
- Variable in C
- Storage class in C
- Const Qualifier in C Language
- The understanding of volatile qualifier in C
- Use of volatile and const keyword together