Type Qualifiers in C++

February 14, 2023

What are type Qualifiers in C++?

C++ provides us with the feature to add extra quality to our variables by specifying volatility or constantness to them. C++ programming language provides us three types of type qualifiers:-

const
volatile
mutable

Further in this article, we will learn more about each type of qualifier in C++.

Definition C++ provides us with the feature to add extra quality to our variables by specifying volatility or constantness to them. These extra qualities are added with the help of tokens known as type qualifiers.

In general words, we can say those type qualifiers are the tokens that add special qualities to the variables. These qualities specify where the variables are to be stored in a memory and how they can be accessed from there.

C++ programming language provides us three types of type qualifiers:-
1. const
2. volatile
3. mutable

What is const type qualifier in C++?

If the type of object is cont then this type of object cannot be modified
If we try to modify the const type of object then there will be a compile-time error.
An object whose type is const type qualifier is a const object.

Syntax:

 const data_type variable = value;

C++ Introduction

History of C++

Structure of a C++ Program

Program to check armstrong number or not

Example

Run

#include <iostream>
using namespace std;
 
int main()
{
    const int var = 10;
    cout << var;
    
    var = 20; // error: Const values can't be changed
 
    return 0;
}

What is a volatile type qualifier in C++?

Saying that a variable is volatile would mean for us to tell the compiler to not optimize the code as the value for something may change.

To understand this we will need to take the below scenario –

int var = 123;

while(var == 123)
{
   //your code
}

Forced Optimization by compiler When this program gets compiled, the compiler may optimize this code, if it finds that the program never ever makes any attempt to change the value of var So it may be tempted to optimize the while loop by changing it from while(var == 123) to something which is equivalent to while(true) This may be done so that the execution could be fast (since the condition in while loop appears to be true always). (if the compiler doesn't optimize it, then it has to fetch the value of var and compare it with 123, in each iteration which obviously is a little bit slow.)

Sometimes Optimization is bad However, sometimes, optimization (of some parts of your program) may be undesirable, because it may be that someone else is changing the value of some_int from outside the program which compiler is not aware of, since it can't see it; but it's how you've designed it. In that case, compiler's optimization would not produce the desired result! So, to ensure the desired result, you need to somehow stop the compiler from optimizing the while loop. That is where the volatile keyword plays its role. All you need to do is this,

volatile int var = 123; //note the 'volatile' qualifier now!

We can do below that is just add a volatile keyword and the compiler will not optimize the code and knows the code/variables etc maybe sensitive that is volatile

volatile int var = 123;

while(var == 123)
{
   //your code
}

What is a mutable type qualifier in C++?

Const objects do not allow data member values to be changed. They can only be read after initialization and not updated again. Data members which are mutable are allowed to change their values even if they are of a const object. This may be needed when almost all other data members are required to remain constant but one may change. It’s a good idea to declare that data member as mutable. The following example demonstrates the same –

Run

#include<iostream>
using namespace std;

class MyClass {
    public:
        int var1;
        // mutable will allow var2 to be updated
        // even though its called by a const object
        mutable int var2;
        
    MyClass(int x=0, int y=0) {
        var1 = x;
        var2 = y;
   }
   void display() 
   {
        cout << endl << "var1: " << var1 << " var2: "<< var2 << endl;
   }
};
int main() 
{
    // const object, we can only read but not change values
    // values can only be initialized once, here we using a
    // parameterized constructor to initialize them
    const MyClass obj(10,20);
    
    // reading values is allowed as we are not changing
    // data members of const object
    cout << obj.var1 << " " << obj.var2 << "\n";
    
    // Below gives error as var1 can't be changed( because object is constant)
    // obj.var1 = 30;
    
    // var2 can be changed as var2 is mutable data member
    obj.var2 = 100;
    
    cout << obj.var1 << " " << obj.var2 << "\n";
    
    return 0;
}

Output

10 20
10 100

Prime Course Trailer

Related Banners

Get PrepInsta Prime & get Access to all 200+ courses offered by PrepInsta in One Subscription

Get over 200+ course One Subscription

Courses like AI/ML, Cloud Computing, Ethical Hacking, C, C++, Java, Python, DSA (All Languages), Competitive Coding (All Languages), TCS, Infosys, Wipro, Amazon, DBMS, SQL and others