Steven Schveighoffer wrote:
In fact, "logical
constness" is a fraud anyway because the underlying data isn't
constant at all, one is completely relying on convention. There's
nothing at all preventing a supposedly logical-const-correct function
from returning a different value every time it is called, and no way
for the compiler to detect this.
This is complete BS. logical const in C++ is not the same as what
logical const in D would be. The transitive guarantee is much more to
credit for allowing optimizations and static analysis than the omission
of mutable members. How does the fact that an Object's monitor is
mutable affect the optimizer?
In fact, how can *any* const or immutable function be optimized any
differently than a mutable function? The only optimizations I can think
of are for pure functions. And a pure function with immutable becomes
significantly less optimizable if some fields might be mutable. Couple
that with the fact that a class may define new mutable members, it would
be impossible to statically prove whether a class is completely
immutable or logically immutable.
But it would be good enough to allow logically-const/immutable to be
different than const/immutable. The problem is that this severely
complicates the const system.
If you are going to argue this case, please do not use C++ as a straw
man, it's not the same as D.
I don't understand your comment. In C++ you can write:
struct S
{
mutable int m;
int getM() { m = rand(); return m; }
};
Where's the "logical const"? It returns a different value every time. Logical
const is not a feature of C++.
