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.
C Constants
Copyright – Cbeginners.com

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*1014 mathematically. But we cannot write the superscript and subscript type of things in a program. So the 1.23*1014 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.

Add a Comment

Your email address will not be published. Required fields are marked *