Variable In C
- C programming, a variable is a named storage location in memory that can hold a value of a specific data type.
- variables are containers for storing data values, like numbers and characters.
- When a variable is declared in C, the compiler sets aside a block of memory for that variable with the specific size of its data type.
- The memory address of the variable is used to access its value during the program execution.
- Variables in C can be different data types such as integer, float, character, double, etc.
- int - it can stores integers like whole numbers
Syntax:
type variableName = value;
To declare a variable in C, you need to specify its data type and a name
for the variable.
For example:To declare an integer variable named x, you would use
the following statement:
For example: int x;
This statement declares a variable named x of type int. You can then assign
a value to the variable using the assignment operator =.
For example: x = 10;
This assigns the value 10 to the variable x. You can also declare and
initialize a variable in a single statement.
For example: int x = 10;
This declares a variable named x of type int and initialize it with the
value 10.
Program:
#include<stdio.h>
int main(){
int num = 10;
float num1=20.0;
char letter='A';
printf("The value of num is: %d\n", num);
printf("The value of float num1 is: %f\n", num1);
printf("The character is: %c\n", letter);
return 0;
}
Output:
The value of num is: 10
The value of float num1 is:20.000000
The character is:A
The character is:A
There are many types of variables in c:
- Local variable.
- Global variable.
- Static variable.
- Non Static variable.
- Automatic variable.
- External variable.
Local Variable:
A local variable is one that is defined within the scope of a function or
block. It is necessary to declare a local variable at the beginning of the
respective block or function.
Program:
#include<stdio.h>
void fun(){
int a=23; // local variable
printf("Value of a is: %d \n",a);
}
int main() {
fun();
}
Output:
Value of a is: 23
Global Variable:
A global variable is a variable declared outside any specific function or
block. Any function in the program can modify the value of this variable,
and it remains accessible to all functions. The global variable needs to be
declared at the beginning of the program.
Program:
#include<stdio.h>
// Declare a global variable outside any function
int global_variable = 10;
// Function that uses the global variable
void printGlobalVariable() {
printf("Global variable value: %d\n", global_variable);
}
// Main function
int main() {
// Call the functions
printGlobalVariable();
return 0;
}
Output:
Global variable value: 10
Static Variable:
A static variable is one that uses the "static" keyword when declared.
Unlike other variables, it keeps its value even when the function it's in
finishes running. This means the variable remembers its value for the next
time the function is called.
Program:
#include<stdio.h>
void fun()
{
static int y=5;
y=y+1;
printf("y= %d\n",y);
}
int main()
{
fun();
fun();
fun();
}
Output:
y=6
y=7
y=8
Non Static Variable:
In C, a non-static variable is a variable that doesn't use the "static"
keyword when declared. These variables are often referred to as automatic or
local variables, and they are created and initialized each time the block or
function in which they are declared is entered. They have a limited scope
and lifetime, existing only within the block or function where they are
defined.
Program:
#include<stdio.h>
void fun()
{
int y=5;
y=y+1;
printf("y= %d\n",y);
}
int main()
{
fun();
fun();
fun();
}
Output:
y=6
y=6
y=6
Automatic Variable:
In C, when you declare a variable inside a block (like a function or a set
of curly braces), it's automatically treated as an "automatic variable." You
don't need to use any special keywords for this to happen. However, if you
want to be explicit, you can use the "auto" keyword.
Program:
#include<stdio.h>
// Function prototype
void exampleFunction();
int main() {
// x is an automatic variable by default
int x = 10;
// Explicitly declaring y as an automatic variable
auto int y = 20;
// Print values of x and y
printf("x: %d\n", x);
printf("y: %d\n", y);
// Call another function
exampleFunction();
return 0;
}
// Another function using automatic variables
void exampleFunction() {
// z is an automatic variable
int z = 30;
// Print the value of z
printf("z: %d\n", z);
}
Output:
x:10
y:20
z:30
External Variable:
In C, if you want to share a variable across multiple source files, you can
use an external variable. To declare an external variable, you use the
"extern" keyword.
Program: main file
// File: main.c
#include<stdio.h>
// Declaration of external variable
extern int sharedVariable;
int main() {
// Accessing the external variable
printf("Value of sharedVariable in main.c: %d\n",
sharedVariable);
// Modifying the external variable
sharedVariable = 42;
// Calling a function from another file that uses the
external variable
externalFunction();
return 0;
}
Program: External file
// File: external.c
#include<stdio.h>
// Definition of external variable
int sharedVariable;
// Function using the external variable
void externalFunction() {
// Accessing the external variable
printf("Value of sharedVariable in external.c: %d\n",
sharedVariable);
}
Compile command:
gcc main.c external.c -o myprogram
./myprogram
Output:
Value of sharedVariable in main.c: 0
Value of sharedVariable in external.c: 42
More topic in C
