Ben Voigt [C++ MVP] wrote:
You should not use const_cast.
In some cases there is no way around it, unfortunately, i.e. when you have
to work with an existing, broken API. Otherwise I completely agree.
Most experts don't use const_cast either.
Good code doesn't need it. Further, there is the alternative 'mutable' which
helps in some cases. However, being an expert means that you know when to
use it and when not.
const_cast generally results in incorrect code because the compiler still
optimizes access to the variable as if it were const, but allows you to
change the value... bad bad bad.
Ben, this is a point I don't understand. Assuming this code:
int const i = 5;
const_cast<int&>(i) = 42;
std::cout << i << std::endl;
the output with some modern compilers will indeed be 5 instead of 42, but
this is a non-issue because it causes 'undefined behaviour' anyway, i.e.
the code is broken. If you meant that, I agree.
Otherwise, a compiler is non-compliant if casting away const doesn't work.
Assuming this code:
void mutate( int const& i) {
const_cast<int&>(i) = 42;
}
int i = 5;
mutate(i);
std::cout << i << std::endl;
I would assume the compiler to behave properly and output 42. Do you know of
any compilers that don't?
It should. It is only undefined behaviour if the variable/object being
modified was originally created as const. Here, i is not. And hence,
the modification should work. Don't know of a compiler that would go