I have a very simple program which just outputs indefinitely a const pointer pointing to a const volatile char; it goes like this:
const volatile char* const str = "ABCDEFGHIJKL";
while(true) {
cout << '\r' << str;
}
The problem is that when running this program, the output is 1. There is a way to get around this, which is outputting const_cast<char*>(str)
instead of str
.
But if I do const_cast<volatile char*>(str)
the output is 1, just like before the cast, so I'm guessing the 1 output is caused by the volatile
keyword, which is strange because I thought that volatile only makes the compiler avoid optimizations in that variable, which shouldn't change the value of it.
My question, therefore, is how in the world did that 1 came as the output.
NOTE:
I've tried compiling it with GCC in Ubuntu 16.04, and with MinGW in Windows 7, so the compiler is not the problem(I guess).
Yes a C++ variable be both const and volatile. It is used in situations like a read-only hardware register, or an output of another thread. Volatile means it may be changed by something external to the current thread and Const means that you do not write to it (in that program that is using the const declaration).
The const keyword specifies that the pointer cannot be modified after initialization; the pointer is protected from modification thereafter. The volatile keyword specifies that the value associated with the name that follows can be modified by actions other than those in the user application.
We use 'const' keyword for a variable when we don't want to the program to change it. Whereas when we declare a variable 'const volatile' we are telling the program not to change it and the compiler that this variable can be changed unexpectedly from input coming from the outside world.
Let us get one thing straight: the concepts of const and volatile are completely independent. A common misconception is to imagine that somehow const is the opposite of volatile and vice versa. They are unrelated and you should remember the fact.
You got nuked by Implicit conversion Sequences (ICS). The C++ std::ostream
facilities have no overloads for volatile
types. ICS kicks in, and selects the overload for bool
type (because pointer types, irrespective of cv qualifications are implicitly convertible to bool
).
Hence you see 1
... Change your output to std::boolalpha
and you should see true
instead.
Example:
#include <iostream>
#include <iomanip>
int main(){
const volatile char* const str = "ABCDEFGHIJKL";
std::cout << '\r' << str;
std::cout << '\r' << std::boolalpha << str;
}
Prints:
1
true
Demo
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With