RCArray is unsafe

[deadalnix via Digitalmars-d]

On Tuesday, 3 March 2015 at 01:56:09 UTC, Walter Bright wrote:
> On 3/2/2015 4:40 PM, deadalnix wrote:
>> After moving resources, the previous owner can no longer be 
>> used.
>
> How does that work with the example presented by Marc?

I'm not sure what you don't understand. The comment in the sample 
code seems clear to me.

// "Move" `a` into `b`
// Here's what happens under the hood: the pointer `a` gets 
copied (*not*
// the data on the heap, just its address) into `b`. Now both are 
pointers
// to the *same* heap allocated data. But now, `b` *owns* the heap
// allocated data; `b` is now in charge of freeing the memory in 
the heap.
let b = a;

Now you have a variable b that owns the data. a is not usable 
anymore.

// After the previous move, `a` can no longer be used
// Error! `a` can no longer access the data, because it no longer 
owns the
// heap memory
//println!("a contains: {}", a);
// TODO ^ Try uncommenting this line

As explained here, if a is used, this is an error.

In the example a is move to b. If you had let b = &a, then b 
would borrow from a. The same way, a would not be usable anymore. 
The difference with move is that, when b is destroyed, in the 
first case memory is freed. in the second case, memory is not 
freed and a is "reenabled".

It is either possible to borrow once and disable who you borrow 
from, or borrow multiple time and everything become immutable for 
the time you borrow.

This makes the problems mentioned in this thread effectively 
impossible happen.