Different Ways To Declare Variable As Constant In C And C++

Different Ways To Declare Variable As Constant In C And C++

Various Methods to Declare Variable Constant

There are various methods to make a variable constant.

1. Const keyword

One way is by using the const keyword. When you declare a variable with const, it means that its value cannot be changed once it’s set, and this is determined at compile time.

// C program to demonstrate const specifier
#include <stdio.h>
int main()
{
    const int num = 1;
  
    num = 5; // Modifying the value
    return 0;
}

When you declare a variable as const and then try to change its value, the compiler will generate an error similar to the one you mentioned: “error: assignment of read-only variable ‘num’.” This error is a safeguard to ensure that you don’t accidentally modify a constant variable.

2. Enum keyword

The enum keyword: is used to define an enumeration in C and C++. Enumerations allow you to assign names or labels to integral constants, making the code more readable and maintainable. Here’s an example of how you might use enum in C++:

// In C and C++ internally the default
// type of 'var' is int
enum VARS { var = 42 };
  
// In C++ 11 (can have any integral type):
enum : type { var = 42; }
  
// where mytype = int, char, long etc.
// but it can't be float, double or
// user defined data type

3. Using constexpr keyword

In C++, the constexpr keyword is used to declare variables as guaranteed constants. When you declare a variable, it must be initialized with a constant expression. This means that the value must be computable at compile time, not runtime. If the initializer of a constexpr variable isn’t a constant expression, the code will fail to compile. This helps ensure that constexpr variables are indeed constants that can be determined at compile time for optimization purposes.

#include <iostream>
  
int main()
{
    int var = 5;
    constexpr int k = var;
    std::cout << k;
    return 0;
}

If you attempt to initialize a constexpr variable with a value that cannot be determined at compile time, you will receive an error message like the one you mentioned: “error: the value of ‘var’ is not usable in a constant expression.” This is a compiler error designed to enforce the rule that constexpr variables must be initialized with constant expressions.

If you want a variable to be a true constant, which means its value cannot be changed after initialization, you should declare it using the const keyword.

4. Using Macros

Macros can be used to define constants in C and C++. However, there are some important considerations and potential issues when using macros for constants.

Macros in C and C++ are handled by the preprocessor, and they perform simple text replacement in your source code before it’s compiled. This text-based substitution means that macros lack type checking, and they can indeed be redefined or changed throughout your codebase, leading to potential errors and unexpected behavior.

// C++ program to demonstrate the problems
// in 'Macros'
#include <iostream>
using namespace std;
  
#define var 5
int main() {
    printf("%d ", var);
  
    #ifdef var
    #undef var
  
    // redefine var as 10
    #define var 10
    #endif
  
    printf("%d", var);
    return 0;
}

Output

Output: 5 10

Note :

1. Preprocessor Macros: Preprocessor macros are essentially text replacements and are suitable for defining literal constants. They are not associated with any specific data type or memory location. They are primarily used for simple text substitution and should be avoided for more complex constant requirements.
2. Enums: Enums provide symbolic names for integral constants and are suitable for defining integer constants. Enums do not have specific memory addresses and are typically used for making code more readable and maintainable.
3. const and constexpr: const and constexpr are used to define true constants with specific memory addresses. They provide type safety and are the recommended way to define constants when you need them to have a particular data type and memory location. const is used for runtime constants, while constexpr is used for compile-time constants.

In practice, const and constexpr are preferred for defining constants when you need type safety, memory control, and more versatile constant values. Preprocessor macros and enums have their use cases but may not offer the same level of control and safety as const and constexpr.

FAQ- Different Ways To Declare Variable As Constant In C And C++