When man created computers, he created what is called a memory. A memory is a space where we can store something. Depending on the size of your computer, this storage spaces are numerous. Each storage space has it’s address. Memory spaces are located in a given address.
So when we code and we declare and define a variable, we are simply giving a memory space with its address an English name.
It is easier for us human to remember a variable name than remember memory addresses of a computer.
So basically a variable is the name of a memory location.
Variables in C
Declaring Variables
Before you use a variable, you will need to declare it and then define it.
So what are you doing when you actually declare a variable?
When you declare a variable, you are basically announcing to the computer that a variable name exists. In other words, you’re telling the compiler that the variable definition exists somewhere in the computer and that it can continue its compilation without worrying.
To achieve only the declaration of a variable in C, we use the keyword – extern;
extern int num1;
extern int num2;
Even though it is possible to declare a variable multiple times in a C program, it is only possible to define it only once such as in a file or a function.
Defining Variables
When you define a variable, you are then asking a computer to assign a memory location and how much storage is to be allocated to your variable name.
You can define a variable name only once.
Luckily declaration and definition of variables happen always at the same time. Throughout your programming career, you will almost always need to declare and define variables at the same time.
Example of declare and defined variable:
int a;
int i;
int z;
The above code tells the computer or compiler to create three values of and assign them storage spaces with the size of an integer which is usually 4bytes (depending on your system).
Initializing Variables.
Variables are initialized when they’re assigned an initial value by the user.
Example
int a = 3;
int i;
i = 50; //initialization
We call them initialized variables because although this is the first value assigned to a variable, this value can change.
Naming variables
As a conventional protocol, certain rules are giving to the way variables are named depending on your programming language In C language the naming convention rules include:
- A variable can have alphabets, digits, and underscore.
- A variable name can start with the alphabet, and underscore only. It can’t start with a digit.
- No whitespace is allowed within the variable name.
- A variable name must not be any reserved word or keyword, e.g. int, float, etc.
Variable Scopes
A scope of a variable is basically an indication of where a variable lives in a program. In other words where a variable is defined. There are two scope environment in a computer program.
1) Global Environment
2) Local Environment
Local Environment and Local Variables
Any where within a statement block or function block is a local environment. In programming, all blocks start with a curly braces {}.
Whether it is an if-else statement, for loop, while loop or a function, when you declare a variable within a block, that variable is said to be a local variable within that block to which it is created. That means, as soon as that block has finished its work, that variable will cease to exist in memory and therefore no longer be accessible for use.
Example of local Variable:
#include <stdio.h>
void person()
{
// Local Variables of the function
int age = 20;
float height = 5.6;
printf("age is %d \n", age);
printf("height is %f", height);
}
int main()
{
person();
return 0;
}
If a local variable is not initialized and you try to read a value from it, you get an undefined behavior.
Global Environment and Global Variables
Global Environment is the program as a whole. See it as the founding paper where you write all your code.
Every variable declared and defined here are known as global variables. They are accessible from anywhere.
Example of a global variable
#include <stdio.h>
// Declaring global variable
int a = 23;
void function1()
{
// Function using global variable a
printf("The number is %d \n", a);
}
void function2()
{
// Function using global variable a
printf("The number is %d \n", a);
}
int main()
{
// Calling functions
function1();
function2();
return 0;
}
If there is anything you should know about global variables, it is that all global variables have a default value of 0 if they are not initialized during definition.
Types of Variables
There are so many types of variables that helps with different contexts in a code.
Automatic Variables
Automatic variables are variables whose lifetime is within a code block only. Technically all local variable are automatic variable. There default value is garbage.
As soon as its block of code has been executed, it gets automatically destroyed.
We use the keyword auto to define it.
#include <stdio.h>
void value()
{
int a = 10; //local variable
auto int b = 20; //automatic variable
printf("The value of local variable: %d \n", a);
printf("The value of automatic variable: %d \n", b);
}
int main()
{
value(); //calling function
return 0;
}
Static Variable
According to Wikipedia, in computer programming, a static variable is a variable that has been allocated “statically”, meaning that its lifetime (or “extent”) is the entire run of the program.
So what this means is that a static variable remains in the memory space during the execution of the entire code. This means that it does not matter where a static variable is declared, locally or globally, a static variable prevents a variable from dying as long as the program execution is not yet finished.
However, when a definition of a variable is static, then it means it cannot be used outside the file where it was defined.
Example of static variables:
#include <stdio.h>
void value()
{
int a = 10; // Local variable
static int b = 20; // Static variable
a = a + 10;
b = b + 10;
printf("The value of local variable: %d \n", a);
printf("The value of Static variable: %d \n", b);
}
int main()
{
value();
printf("Calling function 2nd time \n");
value();
printf("Calling function 3rd time \n");
value();
return 0;
}
All you need to know about static variables
- make use of the static keyword
static int b = 20; - The default initialization value of a static variable is zero, even if it is not assigned, which is not the case in a local variable.
- The static variable is only initialized the first time when a function is called. Cannot be initialised more than once.
- The static variable should be initialised to a value and not a variable.
- In a static variable, the memory of a static variable is allocated.
- A global static variable is not accessible outside the program.
Register
In computer memory, a register is usually a special place where the variables are processed quicker. In other to tell a computer we want to process a variable much faster we can use the register keyword to tell it so.
A register variable is defined using the ‘register’ keyword and is stored in a CPU register. It functions as a local variable with rapid processing capabilities. This m The initial value of a register variable is undefined (garbage) and Its lifespan extends until the function’s conclusion.
But do note that a computer also auto registers a variable if it noticies the high frequency at which a variable is always called.
#include <stdio.h>
int main()
{
register int a = 30; // Declaring register variable
printf("The value of register variable is %d", a);
return 0;
}
External Variable
In trying to describe variable declarations, we described the use of extern keyword.
The extern keyword allows you enhance the visibility of your variable. Therefore whilst a variable maybe defined in another file, with the use of the extern keyword you can declare that same variable in a different file.
The extern keyword basically alerts the compiler that whilst you have seen me here, I am defined somewhere else. So the compiler can go ahead with its compilation without throwing errors knowing that the definition of that variable will still be found.
External variables are technically are global variable and has a lifetime during the entire program.
Conclusion
In C programming, think of variables as containers for information. They come in different types, like boxes of different sizes. These boxes can hold numbers, words, and other data. Variables help the computer remember things while it’s running a program. They’re like the building blocks that make software work, and they’re an essential part of every computer program you use.