Variables are names which are declared in order to store a single value that can either be an integer or a character. It is must to declare the type of the variable also i.e int, char etc. Generally there are two types of variables namely :

1. Global variables
2. Local variables

These variables are classified on the basis of their place of declaration.

Global Variables:

• If a variable is declared outside all the functions, then it is said to be global variable.
• A global variable is available to all the functions and each part of the program.
• When a program is executed then a global variable comes into consideration.
• A global variable is destroyed when the program is terminated.
• Global variables can be accessed from any part of the file or program.

Example:

#include
int a;
int b;
char ch;
void main()
{
printf(“\n enter the numbers :”);
scanf(“%d%d”,a,b);
printf(“\n enter the character”);
scanf(“%c”,ch);
}

Now from the above example we can see that ‘a’ and ‘b’ are integer variables and ‘ch’ is a character variable which is declared outside the main function. Therefore, these variables are known as global variables. These variables can be accessed from any part of the program.

Local Variables:

• Local variables are the ones that are defined within a function.
• A local variable comes into existence when any function is entered.
• A local variable is terminated when we exits from the function.
• These variables cannot be accessed from outside the function.
• A local variable needs to be declared every time after the function call.

Example:

#include
int main()
{
int i;
int j;
int add(i,j);
}
int add(int x , int y)
{
int result;
result = x + y;
printf(“%d the result is:”,result);
return result;
}

Now from the above code we can see that all the variables are declared within the function and these variables will be executed when we enter any function. Therefore, these variables are not allowed to be accessed from any part of the code.

Derived data types in C Programming Language are those C data types which are derived from the fundamental data types using some declaration operators.

Now, in this tutorial we will be discussing each of these derived data types in brief as we will again come across these topics in the next coming up sections.

1. Arrays:
Arrays can be defined as a set of finite and homogeneous data elements. Each element of an array is referenced using an index.

For example:
If we the name of an array is AR which have 5 elements then the array will be represented as :
AR[0], AR[1], AR[2], AR[3], AR[4]
Here, these subscripts which are containing the digit is known as an index.

There are various types of arrays namely:

• One dimensional
• Two dimensional
• Multi dimensional

The elements of an array are indexed from 0 to size-1. It is necessary to declare the size of an array before initialization. An array can be initialize by placing the elements of an array within the curly braces.

For example, an array initialization can be done in following manner:

int AR[5] = {5, 2, 6, 8, 3};

A sample program of an array:

#include
Void main()
{
int arr[10];
arr[10] = {1,5,4,6,3,9,14,81,7,11};
printf(“\n %d”,arr[i]);
}

2. Functions:
A function can be defined as a part of the program which is declared by the programmer in any part of the program and a function can be of any name depending upon the choice of the programmer. The function declared can be invoked from other part of the program.

Example of a function:

#include
Float square(float);
Void main()
{
Float num=3.14;
Float sq;
Sq=square(num);
Printf(“%f”,sq);
}

Float square(float x)
{
Return x * x;
}

The above code will print the square of the above given number. square is the name of the function used. And sq is the variable used to store the value of the square. The use of the function before the main function is known as declaration of the function, then comes the definition of a function which takes place outside the main function. Then finally comes the calling of the function which takes place inside the main function.

3. Pointers:
A pointer is a variable that holds the address of the memory space. We can say that if one variable can hold the address of the another variable then it is said that the first variable is pointing to the second.

A pointer is declared in a following manner:

int *temp;

i.e. first we have to declare the type and then the variable name precede by an * (asterisk) sign.

The pointer variable always occupies 2 bytes of memory.

4. Structures:
A Structure can be defined as a collection or a group of variables that are referenced under one name. it is used to keep related information together. Here we use a ‘struct’ keyword to construct a structure.

Example:

Struct bank
{
Char name[30];
Int account_no;
Int amount;
};

Struct b;

In the above example bank is the name of the structure, then we have declared the variables which are the elements of this structure. And b is the object of the structure which is used to refer the elements of the structure.

Elements will be referred as :

b.amount=5000;
b.account_no=2546321;

5. Class:
A class can be defined as a group of objects which are similar or of the same kind. Here a keyword ‘class’ is used to construct a class. A Class almost follows the same declaration procedure as we did in case of structures. But here comes the concept of access specifiers which applies a kind of restriction on the data. There are three types of access specifiers namely public, protected and private.

Example of a class:

Class student
{
Char name[20];
Int roll_no;
Public:
Details();
Display();
};

Student stud;

In the above example the student is the name of the class, and stud is the name of the object. Here two functions details and display are called member functions.

Operators:

An operator can be defined as a thing which is used to represent the operations or specific tasks and the objects of the operations are referred to as operands.

There are various types of operators :

1)     Arithmetic operators

2)     Logical operators

3)     Relational operators

4)     Increment and decrement operators

5)     Conditional operators

6)     Bitwise operators

Now we will look at these operator types one by one.

• Arithmetic Operators:

C provides five basic arithmetic operators for calculations like : addition, subtraction, multiplication, division and remainder which are +, -, *, / and % respectively. All these operators are called binary operators as these require two operands or values.

Arithmetic operators are divided into two types :

• Unary operators : acts on one operand only.
• Binary operators : acts on two operands.

The above table gives the complete idea of the binary operators.

• Logical Operators :

In this section we talks about the logical operators that refers to the ways in which the relationships can be connected. C provides three logical operators. These are :

• Relational Operators:

The relational operator determines the relation among different operands. C provides six relational operators for comparing numbers and characters. The following relational operators are:

• Increment & Decrement Operator:

Increment operator is denoted by ++ and decrement operator is denoted by –.

The  operator ++ adds 1 to its operand and — operator subtracts 1 from the operand.

In other words,

X = x + 1;

Is same as ++x or x++;

And

X = x – 1;

Is same as –x or x–;

• Conditional Operators :

Conditional operator stores a value depending upon the condition. This operator is ternary operator as it requires three operands.

General form is:

Expression1 ? expression2 : expression3

If expression1 evaluates to true i.e. 1, then the value of the whole expression is the value of expression2, otherwise the value of whole expression is the value of expression3.

• Bitwise Operators:

One of the powerful features of C is a set of bit manipulation operators. These permit the programmer to access and manipulate individual bits within a piece of data. The various bitwise operators are :

Now  if we consider the values of A and B to be 20 and 15 then in binary format it will be represented as :

A = 0011 1100

B = 0000 1101

Then the bitwise operators will perform such operations :

1)     A&B = 0000 1000

2)     A|B = 0011 1101

3)     A^B = 0011 0001

4) ~A  = 1100 0011

In the last article we gave an introduction about the kinds of Constants in C Language.

In this article we will discuss only about primary constants and secondary constants will be discussed in the later articles.

1) Integer Constants:

1. It contains at least one digit.
2. Fractions or decimals are not allowed.
3. By default an integer constant is considered to be positive.
4. Blank spaces and commas are not allowed.
5. The range of all the integer constants has been discussed earlier.

For example :

const int age=20;

and

int const age=20;

Above example tells us about the declaration of an integer constants and we can use any of the form as shown above.

2) Real Constants:

1. They are also known as  floating point constants. Fractional and exponential form are the parts of the real constants.
2. It needs to have at least one digit.
3. Decimal point needs to be there.
4. It can be positive or negative but by default real constants are positive.
5. It is similar to integer constants but the difference is that decimal point is required in integer constants.

3) Character Constants:

Characters enclosed in single quotes are known as character constants and characters enclosed within double quotes are known as string constants. There are certain characters which cannot be represented in this manner therefore we follow a different character sequence i.e.

We use:

• ‘\n’ for new line.
• ‘\t’ for space.
• ‘\0’ for null elements etc.

This is all about the primary constants. We will be discussing secondary constants in the next tutorial.

The keyword const can be added to the declaration of an object to make that object a constant rather than a variable.

The general syntax of constant declaration is :

Const data-type name = value;

Here const is known as a keyword that must be used to declare a constant.  Name is the name of the constant, data-type is the type of the data which we are declaring and value is the constant value of the data-type.

For example :

Const int manager_id=001;

Here we declared a constant named as manager_id of type integer which is assigned a value 001.

Types Of Constants:

C constants can be divided into two categories :

• Primary constants
• Secondary constants

Primary constants are further divided into :

• Integer constants
• Real constants
• Character constants

Secondary constants are further divided into :

• Array
• Pointers
• Union
• Structures
• Enum etc

A storage class is used to tell the compiler how to store the variables and functions within a program or code. It is generally represented as :

Storage-class type variable-name ;

Different types of storage classes used in a C program are :

1. Auto
2. Register
3. Extern
4. Static

The names of these storage classes comes under the list of keywords. Therefore these storage classes are known as reserved words or keywords.

Auto – Storage Class

The storage class auto refers to automatic variable.

Syntax:

Auto type variable-name;

That means the keyword auto just precedes the normal variable declaration.

Note :

In c language all the variables which are defined within a function are automatic or in other words we can say that if we do not apply keyword auto before a variable which is defined within a function will be treated as an automatic variable.

Auto is used only for the local variables.

Example of variable declaration with keyword auto is shown below :

Void main()

{

auto int age;

auto char name;

int roll_no;

int marks;

}

In the above example there are 4 variables defined inside the main function. Out of which two are defined using keyword auto and other two are defined without using it but all these variables will perform the same function.

Register – Storage Class

A register declaration or a register storage class has all the characteristics of an auto variable. But the difference is that, register variables provides faster access as these variables are stored inside the CPU registers instead of storing them in the memory. The register can be applied only to the local variables.

But variable stored in registers should not have any kind of operators attached to it as operators have no allocated memory in the registers.

Syntax:

register type variable-name;

Example of variable declaration with keyword register is shown below :

Void main()

{

register int distance;

register int count;

}

The variables with keywords are defined within the main function which shows that these variables are local variables.

Extern – Storage Class

C Language allows us to split the large program into different files. A file can contain some functions and rest of the files contains the other functions in the program. Then these files can be separately compiled and then later linked together for the program execution. If we have declared a global variable then in c we are not allowed to declare it again in some other file.

The ‘extern’ keyword comes into existence if that other file is using the global variable that is defined outside the file. The extern storage class tells the compiler that the variable types and names that follow it have been declared so that no fresh memory is allocated to these variables.

Note:

The extern storage class is used only for global variables.

• An extern variable is initialized by the program when the file is first loaded.
• Extern is a keyword which is used to represent external variable.
• The lifetime of the external variables remains as long as the program runs.

Syntax:

extern type variable-name;

extern function-prototype;

Example:

extern int I, j;

extern void cube (int x);

The keyword extern is optional for a function prototype.

Static – Storage Class

In C we can have static global variables as well as static local variables. The static variables are permanent within their own function in case of local variables and file in case of global variables. These variables maintain their values between calls. A static global variable is available only inside the file where it has been declared.

When a static modifier is applied to the local variable, it is initialized only when the very first call to the function occurs. It is not finished when the function terminates  but it holds its value even after function’s termination but it can only be accessed within its own function.

Example:

Void fact (void)

{ static int num=10;

Int count=0;

}

A static global variable is useful when we want to create a global variable only for the function of one particular file.

The following Chart will give you the range & sizes of all the data types in C Language along with their Type Modifiers.

This Chart will help you in greater extent in finding the exact range & size of the data types in C Language.

In the previous tutorial we discussed about the primary data types in C Language. In addition, these data types have some modifiers preceding them. The use of these modifiers changes the meaning of the base type.

The memory in the computer is organized in terms of units called bytes. One byte consists of 8 bits and bit is a smallest unit of memory.

Need of Data Modifiers:

Let us take an example of a Program where we need to input the “Salary” of “Employees”  in a team. This program will accept the salary as an input from user and then calculate the Income Tax of that user. We use “int” to store the Salary of the employee as we are assuming that the salary will be in “Whole Numbers”.

An integer data type takes 2 Bytes of Memory and we are aware that the Salary of any of the employee can not be “Negative”. We are using “2 Bytes” to store the memory of an Employee and we can easily save 1 Byte over there by removing the “Signed Part” in the integer. This positive value can easily be stored in “1 Bye Int” This leads us to the user of Data Type Modifiers.

Types of Data Modifiers in C:

The modifiers are listed below :

Signed Type Modifier:

All data types are “signed” by default. Signed Data Modifier implies that the data type variable can store positive values as well as negative values.

For example, if we need to declare a variable to store temperature, it can be negative as well as positive.

signed int temperature;

Or

int temperature;

Unsigned Type Modifier:

If we need to change the data type so that it can only store only store positive values, “unsigned” data modifier is used.

For example, if we need to declare a variable to store the salary of an employee as explained above, we will use “Unsigned” Data Qualifier here.

unsigned int salary;

Long Type Modifier:

Sometimes while coding a program, we need to increase the Storage Capacity of a variable so that it can store values higher than its maximum limit which is there as default. In such situations or programs, we need to make use of the “long” data type qualifier. “long” type modifier doubles the “length” of the data type when used along with it.

For example, if we need to store the “annual turnover” of a company in a variable, we will make us of this type qualifier.

long int turnover;

This variable will take 4 Bytes in memory.

Short Type Modifier:

A “short” type modifier does just the opposite of “long”. If one is not expecting to see high range values in a program and the values are both positive & negative.

For example, if we need to store the “age” of a student in a variable, we will make use of this type qualifier as we are aware that this value is not going to be very high.

short int age;

This variable will consume only 1 Byte in memory.

We can apply the above mentioned modifiers to integer (int) and character (char) base types.

1. Integer Type Modifiers:

• We can use all the above mentioned Type Modifiers for int data type in C Language
• Short int and long int are also termed as short and long respectively.
• Int is signed & unsigned by default.

2. Character Type Modifiers:

• Variables of type char consume 1 byte in memory.
• Char can be signed or unsigned only.
• They have a range of -128 to 127 and 0 to 255 for signed & unsigned respectively.

3. Float Type & Double Type Modifier:

There are 3 types of float type modifiers as given below:

• float
• double
• long double

Double is same as long float. Float type occupies 4 bytes of memory. Type double occupies 8 bytes. Long double occupies 10 bytes. The exception to this is long double, which modifies the size of the double data type to 10 bytes. Please note that in some compilers this has no effect.

Note: We may use long modifier with double data type but it cannot be used with float, i.e. long double is allowed but long float is not allowed because long float is equal to double.

The fundamental data types are of following types:

Integer(int) data type:

Integers are whole numbers. They have no fractional parts. These integers are represented using int data type. Integers can be positive or negative. The integer variable consumes 2 bytes of memory in the code.

Example:

#include
Void main()
{
int num;
num=17;
}

Character(char) data type:

An identifier or a variable which is declared as a char becomes a character variable. The character variable consumes 1 byte of memory in the code.

Example:

#include
Void main()
{
char ch;
char ch1;
ch=’y’;
ch1=’n’;
}

Float(Decimal or Real Number ) data type:

An identifier declared as a float becomes a floating-point variable or a decimal number. Any number which is having a fractional part is known as a floating point variable.

Example:

#include
Void main()
{
float inch;
inch=9.5;
}

Double data type:

Double data type is also used for floating point numbers. But there is a difference in memory consumption. Float data type occupies 4 bytes of memory in the code whereas double occupies 8 bytes of memory i.e. twice as that of float.

Example:

#include
Void main()
{
double rupees;
rupees=6530000;
}

These  data types have some modifiers associated with it which we will be discussing in the next section.

Data can be of many types e.g., integer, fraction or real, character, string etc.

• Numbers that does not have fraction part represents integer data.
• Numbers with decimals or fraction represents real data.
• Any data which is enclosed within single quotes represents character data.
• Any data which is enclosed within double quotes represents a string.

Since the data is of many types, therefore C language provides many ways and options to handle all kind of data.

C Programming Language provides ways to handle different types of data by providing data types.

What is Data Type ?

“Data types” are defined as ways or means to identify the type of data and associated operations of handling it.

Data types can be divided into two types:

• Fundamental or Built-in data types (Primary Data Types)
• Derived data types ( Secondary Data Types)
• User Defined data types

Built-in Data Types:

The basic built-in or fundamental data types that are available in C are:

1. Char
2. Int
3. Float
4. Double
5. Void

Derived Data Types:

The basic derived types that are available in C are:

1. Array
2. Functions and pointers
3. Structures
4. Classes etc..

User defined Data Types:

With the help of a user defined data type, a programmer can create an identifier that denotes an already existing data type. The programmer defined datatype identifier is then used in a program to declare variables.