My question is almost answered. A little confusing about the cache approach.
back even without const_cast, staying fully within C++ type system. This
means that the optimizer is not, after all, allowed to cache the "const"
value in this situation, which in turn means that const_cast doesn't
"George" <George@discussions.microsoft.com> wrote in message
news:B3ADBA4B-0423-4124-8C55-585C0C357A9A@microsoft.com
"Ben Voigt [C++ MVP]" wrote:
void mutate(const int&);
void f(const int* const p)
{
int j = *p;
mutate(*p);
cout << *p << j << endl;
}
int g_theRealVariable = 5;
f(&g_theRealVariable);
void mutate(const int& i)
{
// modify i through a non-const alias
g_theRealVariable = 42;
}
What is your sample tries to prove? I am lost in your sample. :-)
It's trying to show that f() cannot assume *p doesn't change across
other function calls, even though it's declared const, and thus must
re-read *p from memory in the last statement (as opposed to, say,
reusing a value cached in a register from before mutate() call). This is
because, while *p is declared const int, it may refer to a value that is
also accessible as a non-const int (so-called aliasing). In the example,
modify() can change the value of *p through g_theRealVariable (since
both expressions refer to the same object).
Ben used to claim that casting away const and modifying the value is
illegal not only when the object was originally declared const, but also
when a non-const object is known to someone only via a const reference.
He argued that it is legal for the compiler to cache a value of the
"const" object and reuse it later, which would break if const_cast was
used to modify the "const" value behind your back.
But with this example, Ben shows that the value can change behind one's
back even without const_cast, staying fully within C++ type system. This
means that the optimizer is not, after all, allowed to cache the "const"
value in this situation, which in turn means that const_cast doesn't
make matters any worse than they already are (doesn't prevent any
optimizations that would otherwise be allowed).
So the bottom line is: using const_cast to cast away constness and
modify the underlying object is legal as long as the object was not
originally declared const:
void modify(const int* cp) {
// Not illegal in and of itself
int* p = const_cast<int*>(cp);
*p = 42;
}
const int c = 1;
modify(&c); // illegal - c originally declared const
int i = 1;
modify(&i); // legal
--
With best wishes,
Igor Tandetnik
With sufficient thrust, pigs fly just fine. However, this is not
necessarily a good idea. It is hard to be sure where they are going to
land, and it could be dangerous sitting under them as they fly
overhead. -- RFC 1925