Re: C++ Frequently Questioned Answers
Eugene Gershnik wrote:
On Nov 1, 11:45 am, Walter Bright <wal...@digitalmars-nospamm.com>
1) D has two kinds of const: const and invariant. Const is, like C++, an
immutable view of data. Other views of that same data may be mutable.
Invariant represents data that is immutable. C++ does have invariant
when const is used as a storage class, but there's no way to declare a
pointer to immutable data in C++.
Interesting. Is this distinction primarily to help optimizer or does
it have some high level design uses?
Invariant references, unlike const, can be used by the optimizer. The
invariant values can be cached, they are thread safe, they won't be
compromised by exceptions, and there's no need to worry about aliases to
them. Invariant references behave a lot like value types. This works out
particularly well for strings, as people intuitively think about strings
as if they were value types. Language after language (Java, Perl, etc.)
successfully treat strings as invariant without user problems. Strings
as mutable types don't work so well (I often run into code where people
defensively dup strings "just to be sure" someone else doesn't change them).
There's no way to have invariant strings with C++ const. This is often
dealt with by adopting a convention that strings are invariant, but
conventions are not reliable, and widely adopted conventions are ripe
for consideration for adopting into the language.
The sole reason to have const is so that the same function can deal with
both invariant and mutable types, as invariant and immutable can both be
implicitly converted to const.
The other advantages of invariant is it opens the door to being able to
prove things about functions, something that has been very elusive for
C++. It also opens the door to functional programming, a paradigm that
is not available for C++.
2) const (and invariant) in D is transitive. That means if you have a
pointer to const T, anything reachable through that pointer cannot be
mutated. This is different from C++, where although T is const, nothing
T refers to is necessarily const.
Without knowledge of D it is hard to tell whether this would work. How
do you model
'immutable X that knows about mutable Y'?
The const X would have read only access to mutable Y. There is no way to
modify Y through const X. If you want to mutate Y through X, then X must
not be const.
This seems at first blush like "no way, this is a crippling
shortcoming." But is it? All I can say is look at real code, and look
for legitimate use cases of modifying a referenced object through a
One controversial thing that D's const doesn't have is the 'mutable'
keyword which is there to support the notion of 'logical constness'. It
is a deliberate design choice to not support logical constness with the
Hmmm. Rather than give the obligatory 'string that caches the length'
example let me give you something closer to what I usually see
void Lock(); //non const, changes the mutex
void Unlock(); //non const, changes the mutex
int ReadValue() const //doesn't change value
Lock lock(mutex); //for this to work mutex must be mutable
How do you do it in D?
You drop the 'const' from ReadValue(), because it is mutating the
instance of SynchronizedInt. Essentially, D doesn't support the notion
of an object pretending to be const, only objects that actually are. The
idea is that if you see a function signature that says its taking a
const argument, it really truly cross-my-heart promises that it *will
not* be mutating it.
Digital Mars C, C++, D programming language compilers
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]