# C Constants – Tutorial With Examples | C Programming

|From the list of C tutorials, another guide for c learners on C constants. C constants with example programs and syntax. Do check it out.

**What are C constants?**

Constants in any language would depend on the types of data the language supports.

Basically C language has 4 data types and obviously we can say that there are 4 types of constants.

- The data types “char”, “int”, “float” and “double” represent different types of constants we have.

Out of them “float” and “double” represent the numbers with decimal points (Eg: 3.4, 56.33). “int” represents the whole numbers (Eg: 24, 4322). “char” represent the ASCII characters (Eg: ‘A’, ‘e’, ‘5’, ‘+’).

- Basically constants are divided into 2 types i.e. integral and real.
- The integral types are divided into ‘char’ and integer types.
- The ‘char’ type can be used to store any of the 256 ASCII characters (numbered from 0 to 255).
- A set of characters (terminated by a null character) is known as a string.
- To store integer type data, we use two types ‘int’ and ‘long int’.
- The ‘long int’ can store bigger range of values compared to normal ‘int’.
- When we are working with all positive numbers, we can use ‘unsigned int’, and for bigger numbers we can use ‘unsigned long int’.
- By default, ‘int’ means ‘signed int’ where as ‘long int’ means ‘signed long int’.
- The ‘float’, ‘double’ and ‘long double’ types are used to store numbers with decimal points.
- The ‘double’ can hold bigger values compared to ‘float’ and ‘long double’ can hold bigger values compared to ‘double’.
- The ‘double’ type can give better accuracy compared to ‘float’ type.

**What are Character Constants?**

**We have 256 character constants in C language** and they are from ASCII set. To store any such character, a C compiler takes 1 byte of memory (8 bits).

Each character is numbered so that that number would be stored inside the system when we try to store the corresponding character.

Suppose, **for the character ‘A’, the assigned number** is 65 and binary value of 65 (01000001) is actually stored inside the system when we try to store ‘A’.

similarly when we want to store the newline character (‘\n’) in the system, its binary value 01001010 (ASCII value 10) is actually stored.

In the following table, we can see some of the regularly used characters, their ASCII value (ASCII code) and the binary representation.

**Regular Used Characters:**

General name |
ASCII Character/Symbol |
ASCII code |
Binary value |

Null character | ‘\0’ | 0 | 00000000 |

☺ | 1 | 00000001 | |

☻ | 2 | 00000010 | |

♥ | 3 | 00000011 | |

♦ | 4 | 00000100 | |

♣ | 5 | 00000101 | |

♠ | 6 | 00000110 | |

Alert bell
(beep sound) |
‘\a’ | 7 | 00000111 |

Backspace
(cursor one step behind in the current line) |
‘\b’ | 8 | 00001000 |

Tab | ‘\t’ | 9 | 00001001 |

Newline
(cursor to beginning of the next line) |
‘\n’ | 10 | 00001010 |

(Vertical tab)
‘\v’ |
♂ | 11 | 00001011 |

(form feed)
‘\f’ |
♀ | 12 | 00001100 |

Carriage return
(cursor to beginning of same line) |
‘\r’ | 13 | 00001101 |

♫ | 14 | 00001110 | |

☼ | 15 | 00001111 | |

► | 16 | 00010000 | |

◄ | 17 | 00010001 | |

↕ | 18 | 00010010 | |

‼ | 19 | 00010011 | |

¶ | 20 | 00010100 | |

§ | 21 | 00010101 | |

▬ | 22 | 00010110 | |

23 | 00010111 | ||

↑ | 24 | 00011000 | |

↓ | 25 | 00011001 | |

→ | 26 | 00011010 | |

← | 27 | 00011011 | |

∟ | 28 | 00011100 | |

↔ | 29 | 00011101 | |

▲ | 30 | 00011110 | |

▼ | 31 | 00011111 | |

Space | 32 | 00100000 | |

Exclamation | ! | 33 | 00100001 |

34 | 00100010 | ||

Hash | # | 35 | 00100011 |

Dollar | $ | 36 | 00100100 |

Percentile | % | 37 | 00100101 |

Ampersand (and) | & | 38 | 00100110 |

Single quote | ‘ | 39 | 00100111 |

Left parentheses | ( | 40 | 00101000 |

Right parentheses | ) | 41 | 00101001 |

Asterisk (star) | * | 42 | 00101010 |

Plus | + | 43 | 00101011 |

Comma | , | 44 | 00101100 |

Minus (hyphen) | – | 45 | 00101101 |

Dot | . | 46 | 00101110 |

Forward slash | / | 47 | 00101111 |

Digits start here… |
|||

Character 0 | 0 | 48 | 00110000 |

1 | 49 | 00110001 | |

2 | 50 | 00110010 | |

Character 3 | 3 | 51 | 00110011 |

4 | 52 | 00110100 | |

5 | 53 | 00110101 | |

6 | 54 | 00110110 | |

7 | 55 | 00110111 | |

8 | 56 | 00111000 | |

Character 9 | 9 | 57 | 00111001 |

Colon | : | 58 | 00111010 |

Semi-colon | ; | 59 | 00111011 |

Less than | < | 60 | 00111100 |

Equals / assignment | = | 61 | 00111101 |

Greater than | > | 62 | 00111110 |

Question mark | ? | 63 | 00111111 |

At the rate | @ | 64 | 01000000 |

Upper case alphabets start here… |
|||

A | 65 | 01000001 | |

B | 66 | 01000010 | |

C | 67 | 01000011 | |

D | 68 | 01000100 | |

E | 69 | 01000101 | |

F | 70 | 01000110 | |

G | 71 | 01000111 | |

H | 72 | 01001000 | |

I | 73 | 01001001 | |

J | 74 | 01001010 | |

K | 75 | 01001011 | |

L | 76 | 01001100 | |

M | 77 | 01001101 | |

N | 78 | 01001110 | |

O | 79 | 01001111 | |

P | 80 | 01010000 | |

Q | 81 | 01010001 | |

R | 82 | 01010010 | |

S | 83 | 01010011 | |

T | 84 | 01010100 | |

U | 85 | 01010101 | |

V | 86 | 01010110 | |

W | 87 | 01010111 | |

X | 88 | 01011000 | |

Y | 89 | 01011001 | |

Z | 90 | 01011010 | |

Left bracket | [ | 91 | 01011011 |

Back slash | \ | 92 | 01011100 |

Right bracket | ] | 93 | 01011101 |

Cap / carrot | ^ | 94 | 01011110 |

Underscore | _ | 95 | 01011111 |

` | 96 | 01100000 | |

Lower case alphabets start here… |
|||

a | 97 | 01100001 | |

b | 98 | 01100010 | |

c | 99 | 01100011 | |

d | 100 | 01100100 | |

e | 101 | 01100101 | |

f | 102 | 01100110 | |

G | 103 | 01100111 | |

h | 104 | 01101000 | |

i | 105 | 01101001 | |

j | 106 | 01101010 | |

K | 107 | 01101011 | |

l | 108 | 01101100 | |

m | 109 | 01101101 | |

n | 110 | 01101110 | |

o | 111 | 01101111 | |

p | 112 | 01110000 | |

q | 113 | 01110001 | |

r | 114 | 01110010 | |

s | 115 | 01110011 | |

t | 116 | 01110100 | |

u | 117 | 01110101 | |

v | 118 | 01110110 | |

w | 119 | 01110111 | |

x | 120 | 01111000 | |

y | 121 | 01111001 | |

z | 122 | 01111010 | |

{ | 123 | 01111011 | |

| | 124 | 01111100 | |

} | 125 | 01111101 | |

~ | 126 | 01111110 | |

⌂ | 127 | 01111111 |

**What are Integer Constants?**

Any whole number (which does not contain a decimal point) is an integer. An integer can be a positive number or a negative number.

- Eg1: 13
- Eg2: 5999
- Eg3: -552

Generally **integers are represented in decimal number system**. The above 3 values (13, 5999 and -552) are in decimal number system format only.

If we want, we can represent the numbers in octal number system and hexa-decimal number system also.

An octal number is identified by a normal number preceded by 0 (zero) and a hexa decimal number is identified by a normal number preceded by 0x (zero x).

- 25 is decimal number
- 025 is octal number (which is equivalent to decimal 21)
- 0x25 is hexa decimal number (which is equivalent to decimal 37)

Decimal |
octal |
hexa decimal |

0 | 00 | 0x0 |

1 | 01 | 0x1 |

2 | 02 | 0x2 |

3 | 03 | 0x3 |

4 | 04 | 0x4 |

5 | 05 | 0x5 |

6 | 06 | 0x6 |

7 | 07 | 0x7 |

8 | 010 | 0x8 |

9 | 011 | 0x9 |

10 | 012 | 0xa |

11 | 013 | 0xb |

12 | 014 | 0xc |

13 | 015 | 0xd |

14 | 016 | 0xe |

15 | 017 | 0xf |

16 | 020 | 0x10 |

17 | 021 | 0x11 |

18 | 022 | 0x12 |

19 | 023 | 0x13 |

20 | 024 | 0x14 |

21 | 025 | 0x15 |

22 | 026 | 0x16 |

23 | 027 | 0x17 |

24 | 030 | 0x18 |

25 | 031 | 0x19 |

26 | 032 | 0x1a |

27 | 033 | 0x1b |

28 | 034 | 0x1c |

29 | 035 | 0x1d |

30 | 036 | 0x1e |

31 | 037 | 0x1f |

32 | 040 | 0x20 |

33 | 041 | 0x21 |

34 | 042 | 0x22 |

35 | 043 | 0x23 |

36 | 044 | 0x24 |

37 | 045 | 0x25 |

38 | 046 | 0x26 |

39 | 047 | 0x27 |

40 | 050 | 0x28 |

The long int are good to **store bigger values compared to normal int type**. Generally the long int type numbers are suffixed with an ‘l’ or ‘L’.

Eg1: long int a=34L;

Eg2: long int a=34l;

Eg3: long int a=34;

Eg4: long int a=12345678L;

**The float and double constants :-**

The numbers with decimal points (with fractional parts) are represented using ‘float’ and ‘double’ types.

The double is better in terms of accuracy and can hold bigger values compared to ‘float’.

**These values are represented in two forms i.e. fixed and exponential.**

- Eg1: 3456.3 is fixed format
- Eg2: 3.4563e3 is exponential format

The exponential format is very much useful when working with very large numbers or very small numbers.

To represent a number 123000000000000.0, we can write it as 1.23*10^{14} mathematically. But we cannot write the superscript and subscript type of things in a program. So the 1.23*10^{14} is written in a program as 1.23e14 and the number 0.000000000023 can be written as 2.3e-11 (which is written as 2.3*10^{-11} mathematically).

**We can store 4.5 as a ‘float’ value, as a ‘double’ value and also as a ‘long double’ value.**

- Eg1: float a=4.5;
- Eg2: double a=4.5;
- Eg3: long double a=4.5;

**To differentiate between them some compilers accept the following notations.**

- Eg1: float a=4.5F;
- Eg2: double a=4.5;
- Eg3: long double a=4.5L;

A real number suffixed with an ‘f’ or ‘F’ is treated as ‘float’ and when suffixed with ‘l’ or ‘L’ is treated as ‘long double’. By default, a real number is treated as a ‘double’ type.