.dup on an array of BitArray not duplicating

[ixid]

On Tuesday, 15 May 2012 at 20:16:28 UTC, Chris Cain wrote:
> On Tuesday, 15 May 2012 at 19:23:31 UTC, ixid wrote:
>> Not sure if this is a bug or just rather counter-intuitive:
>>
>> BitArray test;
>> test.length = 7;
>> BitArray test2 = test.dup;
>> test2[0] = 1;
>>
>> This is fine, test is not modified.
>>
>> BitArray test[7];
>> foreach(ref i;test)
>>    i.length = 7;
>> BitArray[7] test2 = test.dup;
>> test2[0] = 1;
>>
>> test has been modified. Why doesn't dup work here?
>
> dup doesn't make a deep copy. That is to say, you have a dup'd 
> array of items that have not had dup called on them.
>
> BitArray (? Are you using D1?) apparently uses pointer to its 
> payload. In the first case, you're using BitArray's dup 
> property which knows to create a new payload with the same 
> values as the original.
>
> The second case, you call dup on the static array of BitArrays 
> which makes an exact bit-for-bit copy of the BitArray structs 
> in the array. So, you're getting a new "BitArray" struct which 
> has the exact same information (in this case, including a 
> pointer) as the old BitArray.
>
> So, when you call opAssign (using the test2[0] = 1;), it 
> modifies the payload of the first BitArray, which transitively 
> means that the first BitArray in test also sees the change 
> (because it is using a pointer to the same payload).
>
>
> Also, just as an aside, your first and second examples don't 
> mean exactly the same thing when you do "test2[0] = 1;" In the 
> first one, you're (probably) using BitArray's opIndexAssign and 
> the second one, you're just using BitArray's opAssign.
>
> An equivalent call for the second example would be:
> test2[0][0] = 1;
>
> Which would still have the same problem as you'd still be 
> modifying the payload being pointed at. But it's just something 
> to mention.

Sorry I made a typo in the second, it should be test2[0][0]. I'm 
using std.bitmanip in D2.