Const keyword in C++

Introduction

Overloading is the ability to use a single identifier to define more than one class method that differs from one another in terms of their input/output parameters. In case of overloading, a method is chosen at the compile time. Function overloading is when two or more functions are defined using the same name but differ from each other in terms of type or number of parameters.
Const is a keyword which when attached to any method, variable, or with the object of a class, will prevent that specific object/method/variable from modifying its data items value. A variable which is declared as a const cannot be left un-initialized at the time of the assignment. In this blog, we will discuss how function overloading and const keyword work together in C++.

Using Const Keywords in C++

The const keyword in C++ is used to indicate that a variable, pointer, argument, or member function is constant, meaning its value or behavior cannot be changed after initialization.

Declare a Variable as a Constant

When a variable is declared as const, its value cannot be modified throughout the program. It provides compile-time protection against accidental modifications.

#include <iostream>
int main() {
   const int x = 5; // Declaring x as a constant
   // x = 10; // Error: Attempting to modify a const variable
   std::cout << "Value of x: " << x << std::endl;
   return 0;
}

Declare a Pointer to a Constant

Declaring a pointer as const means the pointer itself cannot be reassigned to point to a different memory location, whereas declaring the pointed-to value as const ensures that the value it points to cannot be modified.

#include <iostream>
int main() {
   int y = 10;
   const int *ptr = &y; // Pointer to a constant integer
   // *ptr = 20; // Error: Attempting to modify a constant value
   std::cout << "Value pointed by ptr: " << *ptr << std::endl;
   return 0;
}

Constant Arguments

Using const in function parameters ensures that the arguments passed to the function cannot be modified within the function's body, providing both readability and safety.

#include <iostream>
void printValue(const int value) { // Using const in function parameter
   // value = 20; // Error: Attempting to modify a constant parameter
   std::cout << "Value: " << value << std::endl;
}
int main() {
   int num = 15;
   printValue(num);
   return 0;
}

Constant Member Functions

Declaring member functions as const promises that they won't modify the state of the object they're called on. This allows these functions to be called on const objects and ensures logical constancy.

#include <iostream>
class MyClass {
public:
   void printValue() const { // Constant member function
       // memberVar = 20; // Error: Cannot modify member variables in a const member function
       std::cout << "Value: " << memberVar << std::endl;
   }
private:
   int memberVar = 10;
};
int main() {
   const MyClass obj; // Creating a const object
   obj.printValue();
   return 0;
}