On Friday, 17 August 2012 at 03:44:38 UTC, Mehrdad wrote:
To clarify... the motivation for this question in the first
place was the fact that I've been consistently told (and have
read) that D const provides more guarantees than C++ const, so
I was trying to figure out how.
If what you're saying is that the extra guarantees only
translate into optimizations when used along with
immutable/pure, then that's a completely valid answer. :) Is
that what you're saying?
(i.e. I DO realize that combining them would give you an
optimization, but the question is -- must you combine const
with something else to gain an advantage over C++?)
Well, I guess if you're modifying globals and you're going to
have your object pointing to those globals, then no you aren't
going to get any optimizations that way. And code like that will
be harder to reason about as well. I'd have a hard time saying
that the "extra guarantees only translate into optimizations when
used along with immutable/pure". I'd say in more realistic code
where you don't do absurd things like intentionally put a global
into a const variable just to mutate the global willy nilly,
you'd get optimizations (although, it'd probably have to check
for those absurd cases as well, but non-trivial optimizations are
still optimizations and it's possible to do).
It is something that would be much more difficult to do with C++
... so much so, that if C++ didn't have the const keyword, I'd
imagine the problem would still be roughly the same difficulty.
Not only does C++ have to check globals like D would, but it has
to check to make sure none of the mutable-marked member variables
change, and if they do, then it would have to check to make sure
that the change wouldn't result in changes in other functions
(even if they're const functions, btw) along the way and ... etc.
But yeah, you do get guarantees with D's const that you don't
with C++ const (mutable keyword, again, which makes C++'s const
useless in all non-trivial cases).
I will say that D's features have a synergy about them and
combining them with another one will make them more powerful than
the two individually. So const + pure is a pretty good
combination. That does make many optimizations (that would
normally be difficult) completely trivial to do.
