In this section, we will learn what the variables are and how to use them in C
What Are Variables? And What Does a Variable Mean? (Define variable)
Let’s say you are good at math and someone asked you to do a calculation. The person gives you a list of data (numbers in this case) as an input to your calculation, but the list is too much to be memorized!
What you can do is to write those numbers on a piece of paper. Now numbers are registered on the paper and you can easily access them whenever you want.
But let’s say other than the first person, there are 2 more people come to you and ask the same request that the first person had.
Again, you need to write all the numbers that each person gives you on a piece of paper for later access.
But wait, now because there are people and not just one person, you need to not just write down numbers, but also associate each set of numbers to each person.
For example:
Jack-list-of-number: 1,2,3,4,5
Ellen-list-of-number: 20,1,33,2,3
Donald-list-of-number: 0,20,10,111,8
By labeling each set of numbers, we can now easily find each person’s list of numbers and if in the future there was a need to modify any list associated to each person, we can do so without worrying about unknowingly modifying the wrong person’s list.
Tagging here in this example helped us to separate each data from the other.
You need to know that these tags just helped us to organize inputs! Without them, the list could still be written down on the paper, but it would confuse us and there’s a chance of picking up a wrong list and associate it with a wrong person.
In the world of C programming, these labels and tags are called `variable`.
You see, pretty much all programs need data. For example, a music player program needs music data; an image viewer needs image data; a calculator needs number data, etc.
But programs for the majority of times get more than one data and so we need to put a name on each one of them, so then at later times finding and accessing data becomes easy. (Just like we did in the example above)
C Variables Syntax
Data-type variable-name;
Variable Types in C
The data-type is explained in data-type section. But in short, it serves two purposes:
- Helping compilers to decide the type of value that can be assigned to that particular variable:
A character string values like “this is a string of characters”, Integer values like 1, 2, 3, 4, float values like 2.3, 4.2, 1000.323, 1.00 etc. all these values are of different types and categories and compilers do care about types! When we declare the type of variable, from that moment forward, we can only assign that type of value to the target variable.
For example:
int firstNumber;
The variable named `firstNumber` is of type `int` (which stands for `integer`) and so we can only assign integer numbers (without fraction) to this variable.
For example:
firstNumber = 10; firstNumber = 0; firstNumber = -44535; firstNumber = 4223;
Note: the sign `=` is not an equal sign but `assign` sign. In C programming `==` is Equal-Sign. You can learn more about them in the C Operators section.
2- Helping compilers to decide how much space in memory should be set aside for that particular variable!
All data type takes a different amount of space in the memory comparing to the other. For example, a variable of type `int` takes enough memory space that we can store values range from -2,147,483,648 to 2,147,483,647. But what if we wanted to store a larger number like 4,000,000,000? In that case, we need a type that can take more memory space to allow us to store larger numbers.
So, depending on the range of values, we can decide how big the internal memory space for the target variable should be by choosing a `data-type`.
Note: the memory space for data-types is system-dependent. This means in one system, a data type like `int` might take 4 bytes and in another one might take 2 bytes. As a result, one system might allow a larger range of values and the other might go for a lower range.
You can learn more about Data-type in its section.
Identifiers in C
A Variable-name which is known as identifer is used to access a memory location. This name is like a label or a door, if you will, to a memory space. Basically, the name of a variable is the pointer to a location in memory where a value can be put in or get from that location.
For example:
int age = 22; float weight = 532.03;
In this example, the compiler will set aside two locations in memory, one that the variable `age` will point to and one that the variable `weight` will point to.
So when we assigned the value 22 to the variable `age`, behind the scene this value is actually stored in the location that the `age` variable pointing at. Likewise, the value 532.03 is actually putted in the memory location that the variable `weight` is pointing at.
Variable declaration in C
The process of creating a variable is called `declaring a variable`.
For example:
int b; float ff;
Here, two variables b and ff are declared. But they don’t have any value assigned to them yet.
Variable initialization in C
The process of putting a value to the variable is called `assigning value` and if we assign a value right where the variable is declared or basically the first time of assigning a value to a variable, the process is called `initialization`.
This is the structure:
Data_type variable_name = value;
For example:
int var1 = 20; long var2 = 1000; double var3 = 3.4; char character = 't';
Naming Variables in C: Naming Conventions
There are some rules that we need to follow when we want to set a name for a variable:
- The name that we use for a variable can contain letters, numbers and underscores (_). For example: jack, ellen2020, _black, sunnySeason, etc.
- A name for a variable can begin with either underscore or letter. For example: _sum, check_point etc.
- We can’t use white space and special characters like !@# %^&*()+ etc. in a variable’s name. For example, these names are illegal: ell en, %%jack, Tony&&, pre-process.
- The C language is case sensitive, which means a variable named `ellen` is different from a variable named `Ellen` or `ELLEN`.
- We can’t create two variables with the same name in the same function or scope. But we can have two variables with the same name: each live in a different function or one live in one function and the other live in the global scope (outside all other functions).
- We can’t use C-language reserved keywords as the name of a variable.
C Reserved Words
Here’s the list of reserved keywords:
| auto | extern | short | while |
| break | float | signed | _Alignas |
| case | for | sizeof | _Alignof |
| char | goto | static | _Bool |
| const | if | struct | _Complex |
| continue | inline | switch | _Generic |
| default | int | typedef | _Imaginary |
| do | long | union | _Noreturn |
| double | register | unsignd | _Static_assert |
| else | restrict | void | #_Thread_local |
| enum | return | volatile |
- Semicolon `;`: the process of creating a new variable is called `declaration statement` and any declaration statement ends with semicolon `;` in C.
Note: We only use data types once when we’re declaring a variable. From that moment afterward, assigning values to a variable does not need mentioning the type of the variable anymore.
For example:
int firstNumber; firstNumber = 100;
As you can see, the second line did not include the type of the variable.
Example: creating C variable
Let’s take a look at a simple example:
int main() {
int firstNumber;
int secondNumber;
scanf("%d %d", &firstNumber , &secondNumber);
int sum = firstNumber + secondNumber;
printf("sum: %d",sum);
return 0;
}
In the program above, the whole idea is to get two numbers from a user and add those numbers together and send the result to the output stream.
Now let’s get into details:
There are three variables in this example: `firstNumber`, `secondNumber` and `sum`.
The variables `firstNumber` and `secondNumber` are declared and there wasn’t any initialization where the declaration happened. The data type of these three variables are int. This means they can store integer values.
After that we have a call to the `scanf()` function. For now, don’t worry about how this function works! Just remember that this function takes inputs from users and assigns those inputs to variables.
So here we asked this function to take two input values from users and assign those values to the `firstNumber` and `sercondNumber` respectively.
After that, we have the `sum` variable.
The `sum` variable is declared and initialized in one statement. The value that this statement is taking is the sum of values in the `firstNumber` and `secondNumber` variables.
Note: in the `assignment` operators section you’ll learn how to assign a value to a variable but in short one of the simplest and most used one is the assignment `=` operator where the values on the right side of this operator will be assigned to the variable on the left side.
So here the values of the `firstNumber` and `secondNumber` variables will be added together and the result will be assigned to the `sum` variable.
Locations where we can declare a variable in C:
Variables can be declared inside a function or outside of it.
If a variable is declared inside a function, it is called `local-variable` which is only accessible in that function and not any other functions. Also, if a variable is created outside of all functions, it is called `global-variable` which is accessible within any function of that program.
Local variables in C Example:
#include <stdio.h>
int sum();
int main() {
int firstNumber = 100;
int secondNumber = 200;
sum();
return 0;
}
int sum(){
return firstNumber + secondNumber;
}
Here, we have declared two variables within the body of the `main` function and tried to access them within the body of the `sum` function. But we will get error when the compiler tries to compile this source code because we used the `firstNumber` and `secondNumber` in the `sum` function but this function cannot see these two variables and their values because they are declared within the body of the `main` function and so the `sum` function consider them as undeclared variables!
Basically, to the eyes of the `sum` function, these two variables do not exist at all because they are not declared outside of all functions nor in the body of the `sum` function itself.
Note: a function can only see and work with variables that exist globally or within the body of that function. Check the function section for more information.
Now if we declare the two variables outside the `main` function (AKA globally), then these two variables will be visible to the eyes of `sum` function.
Global variables in C Example:
#include <stdio.h>
int sum();
int firstNumber;
int secondNumber;
int main() {
firstNumber = 200;
secondNumber = 300;
int result = sum();
printf("result: %d",result );
return 0;
}
int sum(){
return firstNumber + secondNumber;
}
If you compile and run the example above, you’ll see that the `result` is 500.
This is because we have declared the two variables outside of any functions and so any function in the source code can access them and change their values if needed and these changes will be visible to other functions as well.
Multiple variable declarations in C:
In C, it is possible to declare multiple variables just in one statement.
This is the structure of creating multiple variables in one statement:
Data-type variable_one, variable_two, variable_n;
In this structure, each variable is separated via colon `,`.
For example:
int variable_one, variable_two, variable_n;
In the example above, we’ve created 3 variables of type `int`.
Note: we could also assign values directly to each variable if we wanted.
For example:
int variable_one = 10, variable_two = 30, variable_n = 50;
C Variable Reading
Reading a variable means getting the current value in that variable.
In order to get the value of a variable anywhere in a program, all we need to do is to simply call that variable.
Note: as long as this call is not on the left side of an assignment operator, the value of the target variable will return. But if we put a variable on the left side of an assignment operator, the variable will act as taker and not a giver! Basically, in that position, we’re able to assign a new value to the variable instead of taking a value from it.
Example: Reading a variable in C
#include <stdio.h>
int main() {
int firstNumber = 200;
int secondNumber = firstNumber;
printf("The value of the secondNumber variable is: %d",secondNumber );
return 0;
}
Output:
The value of the secondNumber variable is: 200
Here, the `firstNumber` variable was first on the left side of the assignment `=` operator. This means in such a position, the variable is capable of receiving a value and replace its current value (if any) with a new one.
At the second statement, we can see the `firstNumber` is now on the right side of the assignment operator. This means the variable now returns its current value (it will return a copy of whatever is in its memory). So here a copy of this value is assigned to the `secondNumber` variable.
Constant Variables: What is the Constant Variable?
Sometimes we have a variable and want to assign a value to it once and after that only read the value. Basically, we don’t want to accidentally or intentionally assign a second value to the variable after its initialization.
This is an example of constant variable! Basically, in C we can create variables that, after their initialization, they won’t accept any other values throughout the lifetime of the program.
In order to create a constant variable, we use the keyword `const`.
Note: In the constant qualifier section, we will get into this topic in a greater detail.
Example: creating constant variables in C
#include <stdio.h>
int main() {
double const pi = 3.14;
printf("The value of the pi variable is: %f",pi );
return 0;
}
Output:
The value of the pi variable is: 3.15
Here `pi` is constant and so we can’t reassign a value to it after its initial value. If we do so, we will get a compile time error.
Example: C constant identifier
#include <stdio.h>
int main() {
double const pi = 3.14;
pi =2323.342;
printf("The value of the pi variable is: %f",pi );
return 0;
}
Output:
error: assignment of read-only variable 'pi' pi =2323.342;
As you can see, because we’ve tried to reassign a value to a constant identifier, we got a compile time error.
Difference between Constant and Variable
A variable is capable of reassigning its current value as many times as needed in a program. But a constant identifier, as the name suggests, only takes an argument once and there’s no way to reassign it later in a program. If we do so, we will get a compile time error.
