Persistent list

[Jonathan M Davis via Digitalmars-d]

On Sunday, 15 November 2015 at 18:26:56 UTC, Ola Fosheim Grøstad 
wrote:
> On Sunday, 15 November 2015 at 15:14:38 UTC, Jonathan M Davis 
> wrote:
>> mutating is undefined behavior, arguing that if it weren't, it 
>> would be like C++'s const and that C++'s const is pretty much 
>> useless, because it doesn't provide actual guarantees.
>
> Hm, I think C++ const requires that the object isn't modified, 
> but you can cast away const in order to call functions that are 
> erroneously missing a const specifier.
>
> C++'s solution is to have a "mutable" specifier for fields like 
> that can be mutated without affecting the type's state 
> externally (mutexes etc).
>
> From the C++ faq:
>
> «NOTE: there is an extremely unlikely error that can occur with 
> const_cast. It only happens when three very rare things are 
> combined at the same time: a data member that ought to be 
> mutable (such as is discussed above), a compiler that doesn’t 
> support the mutable keyword and/or a programmer who doesn’t use 
> it, and an object that was originally defined to be const (as 
> opposed to a normal, non-const object that is pointed to by a 
> pointer-to-const). Although this combination is so rare that it 
> may never happen to you, if it ever did happen, the code may 
> not work (the Standard says the behavior is undefined).»
>
> So const_casting away const followed by mutation is undefined 
> behaviour.

As I understand it, the only time that casting away const and 
mutating is undefined behavior in C++ is when the object was 
specifically constructed as const such that no mutable reference 
to it even can exist without a cast - which would be the bit from 
that quote where it talks about "an object that was originally 
defined to be const". And in general, _very_ few objects are 
likely to be constructed as const. So, in general, in C++, you 
can cast away const and mutate as much as you'd like. It's just 
that that's generally considered bad practice, and folks usually 
behave themselves and try to use const as a "logical" const such 
that no member variables which would normally be considered part 
of the state of the object have a different value after a const 
function call than what they had before the function call. So, 
for the most part, const works by convention.

- Jonathan M Davis