6/16/24, 11:01 AM C - Constants

C - Constants
A constant in C is a user-assigned name to a location in the memory, whose value
cannot be modified once declared. This is in contrast to a variable in C, which is
also a named memory location, however whose value may be changed during the
course of the code.

Instead of repeatedly using hard-coded values in a program, it is advised to define a

constant and use it. Constants in a C program are usually employed to refer to a
value which may be error-prone if it is to be used repetitively in the program, at the
same time its value is not likely to change.

For example, the value of mathematical constant PI is a high-precision floating point

number 3.14159265359, and if it is likely to appear frequently, it is declared as a
constant and used by its name.

We may consider a constant in C as a read-only variable, as its value can only be

used subsequently but cannot be modified.

You can declare a constant in C program with either of the following two ways −

Using the const Keyword

Using the #define Directive

Let's understand these two ways of declaring a constant in C.

Defining a Constant Using the const Keyword

The syntax of declaring a constant is as follows −

const type NAME = val;

For example,

const float PI = 3.14159265359;

We can now use PI in any expression, as we would use any variable.

Example

https://www.tutorialspoint.com/cprogramming/c_constants.htm 1/5
6/16/24, 11:01 AM C - Constants

Take a look at the following example −

#include <stdio.h>

int main(){
const float PI = 3.14159265359;
float radius = 5;
float area = PI*radius*radius;
printf ("area: %f", area);
return 0;
}

Output

On running this code, you will get following output −

area: 78.539818

However, changing the value of a constant is prohibited. The following statement

gives a compiler error −

const float PI = 3.14159265359;

PI=22/7;

Here, you will get the following error message −

error: assignment of read-only variable 'PI'

In case of variables, you can declare a variable and assign it a value later on in the
program, however you cannot follow the same process in case of a constant.

You can declare a constant in C without assigning it a value. But when you try to
assign it a value afterwords, then the compiler will throw an error.

const float PI;

PI = 3.14159265359;

Here, you will get this error message −

error: assignment of read-only variable 'PI'

https://www.tutorialspoint.com/cprogramming/c_constants.htm 2/5
6/16/24, 11:01 AM C - Constants

Note: "sizeof" returns "size_t". The type of unsigned integer of "size_t" can vary
depending on platform. And, it may not be long unsigned int everywhere. In such
cases, we use "%zu" for the format string instead of "%d".

This is because the compiler assigns a random garbage value at the time of
declaration, which you cannot change afterwards. Hence, you must declare and
initialize the constant at once.

A constant in C can be of any of the data types including primary data types such
as int, float, char, and derived data types such as struct.

Defining a Constant Using the #define Directive

Using the #define preprocessor directive is also an effective method to define a
constant. Here is its syntax −

#define name = value

Take a look at the following example:

#define PI = 3.14159265359

Although the constant so defined can also be used in any expression (just as the one
with the const keyword), there is a difference between the two.

The constants created by the #define directive are not handled by the compiler.
Instead, they behave as macros, whose values are substituted at the runtime.

The other notable difference is that you need not mention the data type of the value
to be assigned to the constant when using the #define directive.

Example: Define a Constant Using the #define

Given below is another example of a constant defined using the #define directive −

#include <stdio.h>
#define LENGTH 10
#define WIDTH 5
#define NEWLINE '\n'

int main() {
int area;
area = LENGTH * WIDTH;
printf("length: %d width: %d", LENGTH, WIDTH);

https://www.tutorialspoint.com/cprogramming/c_constants.htm 3/5
6/16/24, 11:01 AM C - Constants

printf("%c", NEWLINE);
printf("value of area : %d", area);
return 0;
}

Output

Upon running this code, you will get the following output −

length: 10 width: 5
value of area : 50

Since a constant is also an identifier in C, it follows all the rules of forming an

identifier. Identifiers in C are case-sensitive. Hence the convention followed while
defining a constant in C is that it uses uppercase characters, however it is not
mandatory.

Changing the Value of a Constant

By definition, constants are immutable. Why would you change the value of a
constant in the first place? We use constants whose value is supposed to remain
unchanged. To be able to change the value, we would define a variable rather than a
constant.

We have seen that it is not possible to assign a new value to an already defined
constant. However, there exists a workaround with which a new value can be
assigned to a constant.

The technique uses the concept of pointers in C. A Pointer is a variable that stores
the address of another variable. Since it is a variable, its value can be changed.
Moreover, this change reflects in the original variable.

Example: Change the Value of a Constant

The following code demonstrates how to change the value of a constant with the
pointer mechanism −

#include <stdio.h>
int main(){
const int x = 10;
printf("Initial Value of Constant: %d\n", x);

https://www.tutorialspoint.com/cprogramming/c_constants.htm 4/5
6/16/24, 11:01 AM C - Constants

// y is a pointer to constant x
int* y = &x;

// assign new value

*y = 100;
printf("Value of Constant after change: %d", x);
return 0;
}

Output

On executing this code, you will get the following output −

Initial Value of Constant: 10

Value of Constant after change: 100

Note that this technique is effective only for those constants which are defined
using the const qualifier.

If you have defined your constant using the #define directive, then you cannot
apply this process. This is because the pointer has a data type, and it must be of the
same type whose address is to be stored. On the other hand, the constant defined
using the #define directive doesn't really have a data type. It is in fact a macro
whose value is substituted during the runtime.

https://www.tutorialspoint.com/cprogramming/c_constants.htm 5/5