"Copy" does not create independent copy of Dynamic Array - arrays

Question

With reference to on-line documentation found at http://docwiki.embarcadero.com/RADStudio/XE6/en/Structured_Types#Dynamic_Arrays.
It is quite clearly written that to make an independent copy of a dynamic array, use the Copy() function. Example code found at that link also illustrates that after the copy, if you change one array, it is not reflected into the other array as both are independent copies. It does not work for me, however. After the copy as well, if I change one array, the other array automatically changes to receive the same value thus implying that Copy() just did what X := Y would have done. Per documentation, "X := Y" and "X := Copy(Y)" are NOT same.
Here is my code:
type
TTestArray = array of TMyType; //Note: TMyType is a class and not a record.
var
X, Y, Z: TTestArray;
begin
SetLength(X, 1); //create first array
X[0].testString := 'Test Y';
Y := copy(X);
X[0].testString := 'Test Z'; //re-assign another value
Z := copy(X);
X[0].testString := 'Test X';
at this time, testString field should contain different text. So,
X[0].testString should be 'Test X'
Y[0].testString should be 'Test Y'
Z[0].testString should be 'Test Z'
However, all three just have 'Test X' as the value in testString thus implying that Copy() did not create independent copies of the array X. Rather, all three arrays are pointing to the same memory location.
Any way to reliably create independent copies of dynamic arrays (i.e. accomplish what I am trying to do above)?
NOTE (added later): TMyType is a class and not a record. So, per very helpful comments below, this is an expected behavior in case of a CLASS. So, how would I make independent copy of the X into Y and Z in this case?
NOTE 2: Removed "Bug" from subject line. Sorry, Embarcadero...
Note 3: TMyType has to be a class. I have no control over it. It is being created from a web service definition (WSDL) which exposes some functionality of PeopleSoft.

Answer 1

The problem is that you've defined TMyType as:
type
TMyType = class(SomeObject)
....
public
testString: string;
end;
When you create the initial TestArray, it does not get filled with the objects itself, but only with pointers to these objects.
What's going on...
The array thus looks like this:
Array contents of array contents of the heap
-------------+----------------------+-----------------------
X[0] |-> pointer_to_MyType1 |-> MyType1
X[1] |-> pointer_to_MyType2 |-> MyType2
When you copy the array this is what happens:
Array contents of array contents of the heap
-------------+------------------------------+-----------------------
Y[0] |-> copy_of_pointer_to_MyType1 |-> MyType1
Y[1] |-> copy_of_pointer_to_MyType2 |-> MyType2
What you would like to see...
This is what you expected to happen:
Array contents of array
-------------+-------------------
X[0] or Y[0] |-> (copy of)MyType1
X[0] or Y[0] |-> (copy of)MyType2
How to make that happen
However in order for that to be possible you have to define TMyType as:
type
TMyType = record
public
TestString: string;
end;
Now the record itself will be stored in the array and not a pointer to data stored elsewhere.
how would I make independent copy of the X into Y and Z in this case?
If you want to retain the use of classes then you'd have to write your own version of Copy; something like:
uses
System.SysUtils, system.classes, Generics.Collections;
type
TMyList<T: TPersistent, constructor > = class(TList<T>)
public
function CloneArray: TMyList<T>;
end;
implementation
function TMyList<T>.CloneArray: TMyList<T>;
var
i: integer;
temp: T;
begin
Result:= TMyList<T>.Create;
for i:= 0 to SizeOf(self) -1 do begin
temp:= T.Create;
temp.assign(self.items[i]);
Result.Add(temp);
end; {for i}
end;
Obviously the above code assumes that you can get away with using a parameterless constructor.
See also: Correct way to duplicate Delphi object

Answer 2

You should rather create a new question instead of changing or adding to your question/
To answer the second part of your question, the easiest thing would be to create you own CopyMyTypeArray function. Your code for the this would probably be something like this:
function CopyMyTypeArray(ASource: TTestArray): TTestArray;
var
newObject: TMyType;
begin
SetLength(Result, Length(ASource));
for cntr := Low(ASource) to High(ASource) do
begin
// You could put the lines below into a clone method
newObject := TMyType.Create;
newObject.testString := ASource[cntr].testString;
Result[cntr] := newObject;
end;
end;
Please note that you would need to free the objects if you free the dynamic array.
If you are happy with this solution please accept Johan's solution as that answers your initial question.

Answer 3

If you need independent copies of objects, the easiest way is to write a Copy Constructor. A copy constructer takes one argument - a reference to the existing object to be copied - and then initializes its internal fields to the same values as in the original object. This can be done with simple code, or using RTTI.
See also: Correct way to duplicate Delphi object
A configurable TMyTypeFactory (or TMyTypeBuilder) might be also an alternative solution.