Table of Contents
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 :
- 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.
- 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.
const
andconstexpr
:const
andconstexpr
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, whileconstexpr
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++
Q1. How variable declaration in C is different from C++?
Ans. In C, variables must be declared at the beginning of a scope, leading to less readable code. In C++, variables can be declared anywhere in the scope, making the code more intuitive and easier to understand.
Q2.What is a declaration statement in C++?
Ans. In C++, a declaration gives a unique name to something and specifies its type and properties. The moment a name is declared is when it becomes known to the compiler.
Q3. What is a variable declaration and initialization in C++?
Ans.A declaration informs the compiler about an entity’s presence in the program and where it’s located. When you declare a variable, it’s a good practice to also initialize it, which means assigning an initial value to the variable.
Hello, I’m Hridhya Manoj. I’m passionate about technology and its ever-evolving landscape. With a deep love for writing and a curious mind, I enjoy translating complex concepts into understandable, engaging content. Let’s explore the world of tech together