On Thu, 16 Aug 2012 18:14:27 -0400, Mehrdad <wfunct...@hotmail.com> wrote:
Something I'm having trouble undertanding/remembering (sorry, you've
probaby already explained it a billion times)...
I remember being told many times that D's 'const' provides stronger
guarantees than C++'s 'const'.
I just wanted to clarify, is that true for 'const' itself, or is that
referring only to when 'const' is used with other D-specific features
(immutable, etc.)?
I know this is old, just going through my backlog of unread newsgroup
posts.
someone else correctly pointed out that const guarantees make it a viable
interface for both immutable and mutable data. In other words, it
provides the ability to write a function that accepts both mutable and
immutable data, rather than having to write two such functions that would
be identical.
I look at it like this:
immutable provides guarantees such that statically-checked pure is
possible.
const provides guarantees such that I don't have to repeat myself for
everything!
inout provides similar benefits as const, but allows me to to use chaining
without repeating myself for everything.
If it's the former, is there some example piece of code in each
language, for comparison, that shows how the compiler can infer more
from D's const than C++'s?
It's the latter, not the former. The compiler cannot make any assumptions
unless the other guarantees (particularly immutable) are involved.
For example, consider the following function:
int foo(const int *x, int *y)
{
*y += *x;
return *x;
}
If compiled without any context, the compiler *must* re-load *x from
memory, because potentially x == y.
However, if called like this:
int bar(immutable int *x, int *y)
{
return foo(x, y);
}
now, if foo is inlined inside of bar, it *can* make the assumption that x
!= y, and so a reload of *x is not necessary (it must be unchanged).
-Steve
