# Variable and Constant

Variable and Constants

Variable: Variable is a named location in memory used to hold a value that can be modified by a program. Variables are used to hold numbers, strings and complex data for manipulation.

Variable declaration:
int rank = 5;
Here, rank is a variable of int type. Here, the variable is assigned an integer value 5.
• In C, we use variable to allocate certain memory where certain data can store.
• Every variable used in the program should be declared to the compiler.
• It tells the compiler about variable name.
• It specifies what type of data the variable will hold.

Constants and Literals: Constants are fixed values that cannot be altered by the program and it could be numbers, characters, or strings. Constants are sometimes called literals. Literals are data items that never change their value during the entire run of program. A variable can be considered as a name given to the location into the memory where the constant is stored. Eg: int x = 5, float mark = 50.5 etc. There are four types of constant, they are;

1. Integer constant: An integer constant can be a decimal, octal, or hexadecimal constant. A prefix specifies the base or radix: 0x or 0X for hexadecimal, 0 for octal, and nothing for decimal. An integer constant can also have a suffix that is a combination of U and L, for unsigned and long, respectively. The suffix can be uppercase or lowercase and can be in any order.

Here are some examples of integer constants:
`212                  /* Legal */215u                /* Legal */0xFeeL             /* Legal */078                 /* Illegal: 8 is not an octal digit */032UU              /* Illegal: cannot repeat a suffix*/`
Following are other examples of various types of integer literals:
`85                   /*decimal */0213                 /*octal */0x4b                 /*hexadecimal */30                   /*int */30u                  /* unsigned int */30l                  /*long */ 30ul                 /* unsigned long */`

2. Floating-point Constants: A floating-point literal has an integer part, a decimal point, a fractional part, and an exponent part. You can represent floating point literals either in decimal form or exponential form. While representing decimal form, you must include the decimal point, the exponent, or both; and while representing exponential form, you must include the integer part, the fractional part, or both. The signed exponent is introduced by e or E.

Here are some examples of floating-point literals:
`3.14159      /*Legal */314159E-5L   /* Legal */510E        /*Illegal: incomplete exponent */210f        /*Illegal: no decimal or exponent */.e55       /*Illegal: missing integer or fraction */ `

3. Character Constants: Character literals are enclosed in single quotes, e.g. 'x' which can be stored in a simple variable of char type. A character literal can be a plain character (e.g. 'x'), an escape sequence (e.g. '\t'), or a universal character (e.g. '\u02C0'). There are certain characters in C that represent special meaning when preceded by a backslash, for example, newline (\n) or tab (\t). Here, you have a list of such escape sequence codes:

 Escape sequence Meaning \\ \ character \' ' character \" " character \? ? character \a Alert or bell \b Backspace \f Form feed \n Newline \r Carriage return \t Horizontal tab \v Vertical tab \ooo Octal number of one to three digits \xhh . . . Hexadecimal number of one or more digits
Following is the example to show a few escape sequence characters:
`#include <stdio.h>int main(){printf("Hello\tWorld\n\n");  return 0;} `
When the above code is compiled and executed, it produces the following result:
``Hello World ``

4. String constants: A string constant is a set of character enclosed in double quotes " ". A string contains characters that are similar to character literals: plain characters, escape sequences, and universal characters. You can break a long line into multiple lines using string literals and separating them using whitespaces. Here are some examples of string literals. All the three forms are identical strings.

`"hello, dear""hello, \dear""hello, " "d" "ear" `
Defining Constants
There are two simple ways in C to define constants:
• Using #define preprocessor
• Using const keyword
The #define Preprocessor
Given below is the form to use #define preprocessor to define a constant:
#define identifier value

The following example explains it in detail:
`#include <stdio.h>#define LENGTH 10#define WIDTH 5#define NEWLINE '\n'int main(){  int area; area = LENGTH * WIDTH;printf("value of area : %d", area);printf("%c",NEWLINE); return 0;}`
When the above code is compiled and executed, it produces the following result:
`value of area : 50`

The const Keyword
You can use const prefix to declare constants with a specific type as follows:
```const type variable = value;```

The following example explains it in detail:
`#include <stdio.h>int main(){ const int LENGTH = 10; const int WIDTH = 5; const char NEWLINE = '\n'; int area; area = LENGTH * WIDTH; printf("value of area : %d", area); printf("%c",NEWLINE); return 0;}`
When the above code is compiled and executed, it produces the following result:
```value of area : 50```

Note that it is a good programming practice to define constants in CAPITALS.

## Popular Subjects

Join with us on social media to see our updates on your feed.