Summary: In this tutorial, we will learn what the volatile keyword is and when we should use it in our C++ code.
What is Volatile in C++?
The volatile keyword in C++ is a type qualifier used to declare that a variable or object can be modified in a program by something like the operating system, hardware, or any other entity which is outside of the program.
It is used to prevent the compiler from optimizing the code that may seem to it as unchangeable.
Consider the following C++ snippet for instance:
int num = 10
cout << num;
The compiler sees that throughout the program the value of
num is not changing, so is the condition
num == 10.
while loop condition is always
true in the above code, the compiler may tempt to optimize the
while loop by changing it from
while(num==10) to something which is equivalent to
while(true), otherwise, in every iteration, it has to fetch the value of num and compare it with integer 10, which is definitely slower.
However, sometimes we do not want this optimization to happen because we may have designed it in such a way that something else is modifying the value of the integer
num (outside of the program) which the compiler is not aware of.
So, to ensure that the compiler doesn’t optimize the while loop, we use the volatile keyword during variable or object declaration.
Important Points About Volatile in C++
The volatile keyword is a hint to the compiler to avoid aggressive optimization involving the variable or object.
Because volatile is a qualifier, we can also use it on the methods. In that case, those methods can only be called on the volatile instances.