Variables

1

<data type> <variable name>;

1

<data type> <variable name> = <value>;

Variables store the data used in a program. As C is a statically typed language, the type is the property of the variable. This means that once a variable is declared with a particular data type, the variable can only stores data of that particular type. If you are more familiar with Python or JavaScript, this might need getting used to.

Each variable has four attributes shown below.

In our example MileToKm.c program, we have declared two variables called miles and kms. Both of these have a type of float as you can see from the declaration: float miles, kms;.

There are other data types available. For instance, if you want to declare an integer variable, you can do so as follows.

1
2
3

int count;        // declare one variable
float miles, kms; // declare multiple variables
                  // all must be the same type

1
2
3

int count = 3;
float miles = 1.0, kms = 2.0;
float uninit, init = 3.0; // partial initialisation (only init is initialised)

Variable Names

User defined identifiers in C must follow the rules below.

These rules are strict. Also note that names are case-sensitive. Therefore, x is different from X. You should also follow the good practice when naming variables.

Common Mistakes

There are several common mistakes with respect to variable declaration in C. As we have stated before and we will keep on reminding you again, the most common one is an uninitialised variable. To make the example concrete, we will use the following example below.

1
2
3
4
5
6

int main(void) {
  int count;
  count = count + 12;
  printf("%d\n", count);
  return 0;
}

1
2
3
4
5
6

int main(void) {
  int count; // Uninitialised, contains unknown value
  count = count + 12;
  printf("%d\n", count);
  return 0;
}

Unfortunately, such problem cannot be reproduced in the replit below. However, you can still see the warning message from the compiler as follows:

1. Click on "Shell" tab.
2. Compile with GCC using gcc -Wall main.c.

If you have done the command gcc -Wall main.c correctly, you should see the following message.

1
2
3
4
5

$ gcc -Wall main.c
main.c: In function ‘main’:
main.c:5:9: warning: ‘count’ is used uninitialized in this function [-Wuninitialized]
   count = count + 12;
   ~~~~~~^~~~~~~~~~~~

The flag -Wall is used to activate all warnings. It should be read as "double-u - all". The "W" stands for warning. In short, it tells the compiler to give out all warnings.

Another possible "mistakes" are redundant initialisation. It is not so much a problem since the behaviour of the program will still be as expected. In fact, in some online sources, you may see that it is a preferred practice to guard against possible error.

1
2

int count = 0;
count = 123;   // assignment makes previous line redundant

1
2

int count = 0;
scanf("%d", &count); // user input makes previous line redundant

Data Types

As we mentioned, every variable must be declared with a data type. This determines the values that the variable can hold as well as the operations that can be performed on the data.

1
2
3
4
5
6
7
8

#include <stdio.h>

int main(void) {
  printf("Size of 'int' (in bytes): %d\n", sizeof(int));
  printf("Size of 'float' (in bytes): %d\n", sizeof(float));
  printf("Size of 'double' (in bytes): %d\n", sizeof(double));
  printf("Size of 'char' (in bytes): %d\n", sizeof(char));
}

We need to emphasise here that char is not a string. In C, the use of a pair of single quotes is different from the use of the pair of double quotes. In both JavaScript and Python, a string can use either kind of quotes. However, in C, double quotes are strictly for string (or rather, char array) and single quotes are strictly for char. In particular, there can be only one character enclosed in a pair of single quotes in C. Note, however, that escape character is permitted and not counted.

C is often considered to be a strongly typed language where each variable have to be declared with a type. Afterwards, the variable can only hold the data of that type. This is in contrast to weakly typed language where a variable may hold different data type at different time.

Unfortunately, for the primitive data types above, C allows for implicit type conversion. As such, examples is hard to come by. The following video explains this strongly vs weakly (or loosely) typed languages.