Как использовать MOVE для динамических c массивов с записью в качестве элемента и динамического c массива в нем?

Question

Я использую Delphi Rio, и в моей программе много динамических c операций с массивами. Чтобы улучшить скорость копирования длинного массива, я попытался использовать Move. Для 1D динамических c массивов базовых c типов (вещественных, целых) я мог бы управлять использованием Move, но для динамических c массивов с записью в качестве элемента и этой записи с другим массивом динамического c поля у меня есть проблемы, чтобы заставить его работать. То, как я использую MOVE для динамических c массивов файлов записей, после выдачи команды эти файлы продолжают указывать на исходный адрес источника массива источника.

Процедура тестирования: массив_A является динамическим c массив записей, поля данных этой записи являются динамическими c массивами. После выпуска Move (array_A [0], B_array [0], sizeof (Array [0]) * length (arra_A)) затем измените значения в массивах array_B dynamici c, это также приведет к изменениям в значениях array_A! Оба указывают на один и тот же адрес. Как изменить это поведение с помощью MOVE?

Смотрите мой код:

    program ProjArrayMove;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils;

Type

     Arrayint   = Tarray<Integer>;
     Arrayreal  = TArray<Real>;

     RECmember = record
           mcode       : integer;
           mname       : string[30];
           mdynarr_int  : arrayint;
           mdynarr_real : arrayreal;
     end;

     ArrayMember = array of RECMember;

     Procedure FillsRecord (var pRec : RECmember; pSize : integer; pFactor : real);
     // Given a pRec , fills each dynamic array fields with pSize numbers
     var
        idx : integer;
     begin
          setlength(pRec.mdynarr_int,pSize);
          setlength(pRec.mdynarr_real,pSize);
          with pRec do
          begin
               for idx := 0 to pSize - 1 do
               begin
                    mdynarr_int[idx]  := idx;
                    mdynarr_real[idx] := idx * (1.0 + pFactor);
               end;
          end;
     end;


     Procedure FillsArray  (var pArr : ArrayMember; pSizeArray, pSizeRec : integer; pChar : Char);
     // Given a array of records pArr  , fills the array with pSizeArray records
     var
        idx : integer;
     begin
           setlength(pArr,pSizeArray);

           //Fils first record - element 0
           FillsRecord(pArr[0],pSizeRec,2.3);
           pArr[0].mcode := 0;
           pArr[0].mname := '0' + pChar;

           //Fills major array with records , each record with dynamic arrays fields also filled
           for idx := 1 to High(pArr) do
           begin
                FillsRecord(pArr[idx],pSizeRec,idx * 2.3);
                pArr[idx].mcode := idx;
                pArr[idx].mname  := idx.ToString + StringOfChar(pChar,2);
           end;
     end;


     Procedure PrintArray(pArr : ArrayMember);
     // Given an array of records pArr, prints each element including the dynami array fields
     var
        i,j : integer;
     begin
           Writeln(stringofchar('=',20));
           for I := Low(pArr) to High(pArr) do
           begin
                 Write('Idx :' + i.ToString + ' ' );
                 Write('Code :' + pArr[i].mcode.ToString  + ' ' );
                 Write('Name :' + pArr[i].mname + '   ');
                 Write(' mdynarr_int :');
                 for j := Low(pArr[i].mdynarr_int) to High(pArr[i].mdynarr_int) do
                     Write(' ' + pArr[i].mdynarr_int[j].ToString);
                 Write(' mdynarr_real :');
                 for j := Low(pArr[i].mdynarr_real) to High(pArr[i].mdynarr_real) do
                     Write(' ' + FloatToStr(pArr[i].mdynarr_real[j]));
                 Writeln;
           end;
     end;

var
    larray_A, larray_B : ArrayMember;
    idx, lsizeA, lsize_int, lsize_real : integer;
begin
      try
          //Step 1 - Fills the first array with 10 records and its relaed dynamic arrays fields with 5 elements each
          FillsArray(larray_A,10,5, 'A');

          //Step 2- An attempt to ast copy elements of larray_A to larray_B
          Setlength(larray_B, length(larray_A));
          lsizeA := Sizeof(larray_A[0]);

          MOVE(larray_A[0], larray_B[0], length(larray_A) * lsizeA);

          Writeln('========== ARRAY A ==========');

          PrintArray(larray_A);
          readln;

          Writeln('========== ARRAY B ==========');

          PrintArray(larray_B);
          readln;

          //Now change values in item of array B
          larray_B[0].mcode := 777;
          larray_B[0].mname := 'B was changed';
          larray_B[0].mdynarr_int[0]  := 427;
          larray_B[0].mdynarr_real[0] := 784.96;

          Writeln('======= ARRAY B AFTER CHANGES ========');

          PrintArray(larray_B);
          readln;

          Writeln('====== VERIFYING IMPACT IN ARRAY A =======');

          PrintArray(larray_A);
          readln;

          //3-Attemp to use MOVE to copy contet of dynamic arrays fields in records member
          lsize_int := Sizeof(larray_A[0].mdynarr_int[0]);
          lsize_real:= Sizeof(larray_A[0].mdynarr_real[0]);

          for idx := Low(larray_B) to High(larray_B) do
          begin
                setlength(larray_B[idx].mdynarr_int,length(larray_A[idx].mdynarr_int));
                **MOVE(larray_A[idx].mdynarr_int[0],larray_B[idx].mdynarr_int[0],
                     lsize_int * length(larray_B[idx].mdynarr_int) );**

                setlength(larray_B[idx].mdynarr_real,length(larray_A[idx].mdynarr_real));
                MOVE(larray_A[idx].mdynarr_int[0],larray_B[idx].mdynarr_int[0],
                     lsize_real * length(larray_B[idx].mdynarr_real) );
          end;

          Writeln;
          Writeln;

          //Now change values in item of array B
          larray_B[0].mcode := 555;
          larray_B[0].mname := '2nd Change in B';
          larray_B[0].mdynarr_int[0]  := 10427;
          larray_B[0].mdynarr_real[0] := 10784.96;

          Writeln('======= ARRAY B AFTER 2nd CHANGES ========');

          PrintArray(larray_B);
          readln;

          Writeln('====== VERIFYING IMPACT IN ARRAY A =======');

          PrintArray(larray_A);
          readln;

          Writeln('==> It seems that MOVE in record fields of dynamic array type does not work as I expected - WHY ?');
          readln;

      except
        on E: Exception do
          Writeln(E.ClassName, ': ', E.Message);
      end;
end.

Спасибо всем!

Answer 1

Ваш первый вызов Move берет копию ссылок на внутренний массив, но делает это за спиной компилятора и поэтому нарушает подсчет ссылок. С этого момента все остальное, что вы делаете, обречено на провал. Вы не можете использовать Move для управляемых данных.

Чтобы сделать это правильно, вам нужен код, подобный следующему:

type
  TMyRec = record
    Int: Integer;
    Arr: TArray<Integer>;
    function Clone: TMyRec;
  end;

function TMyRec.Clone: TMyRec;
begin
  Result.Int := Int;
  Result.Arr := Copy(Arr);
end;

function CloneRecArray(const Arr: array of TMyRec): TArray<TMyRec>;
var
  i: Integer;
begin
  SetLength(Result, Length(Arr));
  for i := 0 to High(Result) do
    Result[i] := Arr[i].Clone;
end;

Answer 2

Исследовали ли вы внутренние операции копирования для динамических c массивов - _DynArrayCopy in system.pas?

Проверяет тип всех полей внутренних структур данных, копирует простые данные с помощью Move, и рекурсивно вызывает себя для динамических c полей массивов.

Возможно, ваш конечный результат будет таким же.