Constant in C Programming

Constant in C Programming: Constants are fixed values that don’t change during program execution, making your code more reliable and easier to read.

Types of constant in C

In C programming language, a constant is a value that cannot be altered during the execution of a program. There are different types of constants in C, each with its own syntax and rules. 1. Literal Constants

These are fixed values that appear directly in the code. They can be of various types, such as:

• Integer Constants: These include all integer values (e.g., 1, 100, -33).
• Floating-point Constants: Numbers with a decimal point or in exponential form (e.g., 3.14, 0.5, -1.2e3).
• Character Constants: Single characters enclosed in single quotes (e.g., 'a', '1', '$').
• String Constants: Sequences of characters enclosed in double quotes (e.g., "Hello, world!").

Now We will See Each Type in Detail With Example:

Integer Constants:

An integer constant is a number that has no decimal point. It can be either positive or negative, and can be represented in decimal, octal, or hexadecimal format.

Example:

int num = 100; // decimal integer constant
int num2 = 012; // octal integer constant (equals decimal 10)
int num3 = 0x64; // hexadecimal integer constant (equals decimal 100)

Floating Point Constants:

A floating-point constant is a number that has a decimal point. It can be represented in either the decimal or exponential form.

Example:

float num = 3.14; // decimal floating point constant
float num2 = 2E-3; // exponential floating point constant (equals 0.002)

Character Constants:

A character constant is a single character enclosed within single quotes.

Example:

char ch = 'a'; // character constant

String Constants:

A string constant is a sequence of characters enclosed within double quotes.

Example:

char str[] = "Hello, world!"; // string constant

Enumeration Constants:

An enumeration constant is a user-defined type that consists of a set of named constants.

Example:

enum days_of_week {Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday};

Macro Constants

Macro constants are a type of constant that is defined using the “#define” preprocessor directive. Macro constants are used to represent values that do not need to be assigned a data type. Here is an example of a macro constant:

#define MAX_SIZE 100

Define the constant in C Programming

In C programming language, you can define a constant using the #define directive or the const keyword. Here’s how to define constants using each method:

1. Using the #define directive: The #define directive allows you to define a constant value that can be used throughout your program. The syntax for #define is:

#define constant_name constant_value

Example:

#define PI 3.14159

In this example, we have defined a constant named PI with the value of 3.14159.

1. Using the const keyword: The const keyword allows you to define a variable as constant, which means its value cannot be changed during the execution of the program. The syntax for const is:

const data_type constant_name = constant_value;

Example:

const int MAX_VALUE = 100;

In this example, we have defined a constant named MAX_VALUE with the value of 100 as an integer.

Both #define and const can be used to define constants in C programming language. However, the const keyword is preferred because it provides better type checking and is more flexible than the #define directive.

C program that demonstrates the use of the #define preprocessor:

#include <stdio.h>
#define PI 3.14159

int main() {
    float radius = 5.0;
    float area = PI * radius * radius;

    printf("The area of a circle with radius %.2f is %.2f\\n", radius, area);

    #define PI 3.14
    area = PI * radius * radius;

    printf("If we redefine PI as %.2f, the area becomes %.2f\\n", PI, area);

    return 0;
}

In this program, we define the constant PI using the #define preprocessor. We then use this constant to calculate the area of a circle with a given radius. Later in the program, we redefine the value of PI using #define, and show how this affects the calculation of the area.

Importance of Constants

• Maintainability: Constants make it easier to manage values that are used multiple times throughout your code. Changes to such values only need to be made in one place.
• Readability: Using constants with meaningful names makes your code easier to read and understand.
• Safety: Constants prevent accidental modification of values that should be immutable, which can prevent bugs and unintended behaviors.