CONSTANTS IN C

Constants

Like a variable, a constant is a data storage location used by our program. Unlike a variable, the value stored in a constant can't be changed during program execution. C has two types of constants, each with its own specific uses.

The constants in C are illustrated in figure below:

Integer Constants are sequences of digits. There are three types of integers namely decimal ,octal and hexadecimal .

The largest integer value that can be stored is machine-dependent. It is 32767 on 16 bit machine and 2,147,483,647 on 32-bit machine. But it is also possible to store larger integer constants on these machines by appending qualifiers such as U,L and UL to the constants.

e.g.

56789U or 56789u for unsigned integer

987612347UL or 987612347ul for unsigned long integer.

9876543L or 9876543l for long integer.

Real Constants are the numbers with fractional parts and optional leading + or – symbol.

e.g. 0.9876 , -9.786 +98.765 etc which are in decimal notation.

0.65e4 , 1.5e+5 -1.2E-1 etc. in scientific notations.

Single Character constants contains a single character enclosed within a pair of single quote marks. Example: ‘c’ ‘%’ ‘&’ ‘7’ etc.

A String Constant is a sequence of characters enclosed in double quotes. The characters may be letters, numbers special characters and blank space.

Example: “Well come”

“a”

“890”

“*&^%$” etc.

In addition C supports some special backslash character constants that are used in output functions.

For example: ‘\n’ for newline, ‘\t’ for tab, ‘\b’ for back space, ‘\”’ for double quote ‘\\’ for \ and so on.

A small program to illustrate the constants in c .

/* this program illustrates the constants used in C */

#include<stdio.h>

main()

{

printf(“\nIntegers : ”);

printf(“%d, %d , %d”,32767,32767+1,32767+10);

printf(“\nLong integers: ”);

printf(“%ld, %ld, %ld “, 32767,32767+1,32767+10);

printf(“\nUnsigned integers: ”);

printf(“%u,%u,%u”, 32767,32767+1,32767+10);

printf(“\nReal constants:”);

printf(“%f, %f, %f”,3.4,9.9e3,-1.2e-6);

printf(“\nCharacter :%c “,’A’);

printf(“\nA string :%s “, “C programming”);

return 0;

}

output is

Integers : 32767, -32768 , -32759

Long integers : 32767, 32768, 32777

Unsigned integers : 32767, 32768, 32777

Real constants: 3.400000, 9100.000000, -0.000001

Character : A

A String : C programming

All the types of above constants can be classified in to two main categories.

1. Literal Constants 2. Symbolic Constants.

Literal Constants

A literal constant is a value that is typed directly into the source code wherever it is needed. Here are two examples:

int count = 20;

float tax_rate = 0.28;

The 20 and the 0.28 are literal constants. The preceding statements store these values in the variables count and tax_rate. Note that one of these constants contains a decimal point, whereas the other does not. The presence or absence of the decimal point distinguishes floating-point constants from integer constants.

A literal constant written with a decimal point is a floating-point constant and is represented by the C compiler as a double-precision number. Floating-point constants can be written in standard decimal notation, as shown in these examples:

123.456

0.019

100.

Note that the third constant, 100., is written with a decimal point even though it's an integer (that is, it has no fractional part). The decimal point causes the C compiler to treat the constant as a double-precision value. Without the decimal point, it is treated as an integer constant.

Floating-point constants also can be written in scientific notation. In C, scientific notation is written as a decimal number followed immediately by an E or e and the exponent:

1.23E2 is 1.23 times 10 to the 2nd power, or 123

4.08e6 4.08 times 10 to the 6th power, or 4,080,000

0.85e-4 0.85 times 10 to the -4th power, or 0.000085

A constant written without a decimal point is represented by the compiler as an integer number. Integer constants can be written in three different notations:

A constant starting with any digit other than 0 is interpreted as a decimal integer (that is, the standard base-10 number system). Decimal constants can contain the digits 0 through 9 and a leading minus or plus sign. (Without a leading minus or plus, a constant is assumed to be positive.)

e.g. 123

-670

8965 etc.

A constant starting with the digit 0 is interpreted as an octal integer (the base-8 number system). Octal constants can contain the digits 0 through 7 and a leading minus or plus sign.

e.g. 065 034 etc.

A constant starting with 0x or 0X is interpreted as a hexadecimal constant (the base-16 number system). Hexadecimal constants can contain the digits 0 through 9, the letters A through F, and a leading minus or plus sign.

e.g. 0x9F 0X7C 0xAB etc.

Symbolic Constants

A symbolic constant is a constant that is represented by a name (symbol) in our program. Like a literal constant, a symbolic constant can't change. Whenever we need the constant's value in our program, we use its name as we would use a variable name. The actual value of the symbolic constant needs to be entered only once, when it is first defined.

Symbolic constants have two significant advantages over literal constants, as the following example shows. Suppose that we're writing a program that performs a variety of geometrical calculations. The program frequently needs the value ,, (3.14159) for its calculations.For example, to calculate the circumference and area of a circle with a known radius, we could write

circumference = 3.14159 * (2 * radius);

area = 3.14159 * (radius)*(radius);

If, however, we define a symbolic constant with the name PI and the value 3.14, we could write

circumference = PI * (2 * radius);

area = PI * (radius)*(radius);

The resulting code is clearer. Rather than puzzling over what the value 3.14 is for, we can see immediately that the constant PI is being used.

The second advantage of symbolic constants becomes apparent when we need to change a constant. Continuing with the preceding example, we might decide that for greater accuracy our program needs to use a value of PI with more decimal places: 3.14159 rather than 3.14. If we had used literal constants for PI, we would have to go through our source code and change each occurrence of the value from 3.14 to 3.14159. With a symbolic constant, we need to make a change only in the place where the constant is defined.

C has two methods for defining a symbolic constant: the #define directive and the const keyword. The #define directive is one of C's preprocessor directives which is used as follows:

#define CONSTNAME literal

This creates a constant named CONSTNAME with the value of literal. literal represents a literal constant(i.e.value for constant). CONSTNAME follows the same rules described for variable names. By convention, the names of symbolic constants are uppercase. This makes them easy to distinguish from variable names, which by convention are lowercase. For the previous example, the required #define directive would be

#define PI 3.14159

Note that #define lines don't end with a semicolon (;). #defines can be placed anywhere in our source code, but they are in effect only for the portions of the source code that follow the #define directive. Most commonly, programmers group all #defines together, near the beginning of the file and before the start of main().

How a #define Works

The precise action of the #define directive is to instruct the compiler as follows: "In the source code, replace CONSTNAME with literal." Note that #define doesn't replace instances of its target that occur as parts of longer names, within double quotes, or as part of a program comment. For example, in the following code, the instances of PI in the second and third lines would not get changed:

#define PI 3.14159

/* You have defined a constant for PI. */

#define PIPETTE 100

Defining Constants with the const Keyword

The second way to define a symbolic constant is with the const keyword. const is a modifier that can be applied to any variable declaration. A variable declared to be const can't be modified during program execution-only initialized at the time of declaration. Here are some examples:

const int count = 100;

const float pi = 3.14159;

const long debt = 12000000, float tax_rate = 0.21;

const affects all variables on the declaration line. In the last line, debt and tax_rate are symbolic constants. If our program tries to modify a const variable, the compiler generates an error message, as shown here:

const int count = 100;

count = 200; /* Does not compile! Cannot reassign or alter */

/* the value of a constant. */

Now look at this small program that demonstrates the use of variables and constants.

1: /* Demonstrates variables and constants */

2: #include <stdio.h>

3:

4: /* Define a constant to convert from pounds to grams */

5: #define GRAMS_PER_POUND 454

6:

7: /* Define a constant for the start of the next century */

8: const int NEXT_CENTURY = 2000;

9:

10: /* Declare the needed variables */

11: long weight_in_grams, weight_in_pounds;

12 int year_of_birth, age_in_2000;

13:

14: main()

15: {

16: /* Input data from user */

17:

18: printf("Enter your weight in pounds: ");

19: scanf("%d", &weight_in_pounds);

20: printf("Enter your year of birth: ");

21: scanf("%d", &year_of_birth);

22:

23: /* Perform conversions */

24:

25: weight_in_grams = weight_in_pounds * GRAMS_PER_POUND;

26: age_in_2000 = NEXT_CENTURY - year_of_birth;

27:

28: /* Display results on the screen */

29:

30: printf("\nYour weight in grams = %ld", weight_in_grams);

31: printf("\nIn 2000 you will be %d years old\n",

age_in_2000);

32:

33: return 0;

34: }

Enter your weight in pounds: 175

Enter your year of birth: 1960

Your weight in grams = 79450

In 2000 you will be 40 years old

ANALYSIS: This program declares the two types of symbolic constants in lines 5 and 8. In line 5, a constant is used to make the value 454 more understandable. Because it uses GRAMS_PER_POUND, line 25 is easy to understand. Lines 11 and 12 declare the variables used in the program. Notice the use of descriptive names such as weight_in_grams. We can tell what this variable is used for. Lines 18 and 20 the printf() print prompts on-screen. To allow the user to respond to the prompts, lines 19 and 21 use another library function, scanf() which gets input information. Lines 25 and 26 calculate the user's weight in grams and his or her age in the year 2000. To finish the program, lines 30 and 31 display the results for the user.

NOTE: DON'T try to assign a value to a constant after it has already been initialized.