how to write a const-object container array?

[Steven Schveighoffer]

"sn" wrote
>I want a container (array) which holds const-object, i.e. when someone get 
>an
> object out of this container, he cannot modify it using that reference.
>
> NOTE: I don't want the container array itself to be const, I may insert or
> remove object from that array.
>
> I tried:
>
> class A {}
>
> int main() {
>  const(A) ca[2];
>  const a = new A();
>  ca[0] = a;
>
>  return 1;
> }
>
> $ dmd constarray.d
> constarray.d(4): Error: slice ca[] is not mutable
> constarray.d(6): Error: ca[0] isn't mutable

Unfortunately, because tail-const for class references doesn't exist, you 
cannot do this easily.

There are two ways to do it now.  first, you can use a dynamic array:

const(A)[] ca;
ca ~= new A;

Note that you can't change elements that you have added without doing array 
concatenation, so to replace element 5 for instance you have to do:

// replace ca[5] with element e
ca = ca[0..5] ~ e ~ ca[6..$];

The other way is to have an array of tail-const pointers to classes, backed 
by heap-allocated references to classes:

const(A)* ca[2];

// this is the easiest way I know how to allocate a class reference on the 
heap
A[] tmp = new A[1];
tmp[0] = new A();

ca[0] = &tmp[0];

You can call methods directly on an element:
ca[0].constMethod();

But you can't do comparisons or call the elements' operators if they are 
valid for pointer operations:
ca[0]++; // will increment the pointer, not call A.opPostInc()
*(ca[0])++; // this is what is required

Yeah, it's ugly, and consumes lots of extra memory, but it's all we have to 
work with until Walter can come up with (or accept an existing proposal for) 
a way to have tail-const class references.

-Steve