delphipascal

Move() to Insert/Delete item(s) from a dynamic array of string


Using System.Move() to insert/delete item(s) from an array of string is not as easy as insert/delete it from other array of simple data types. The problem is ... string is reference counted in Delphi. Using Move() on reference-counted data types needs deeper knowledge on internal compiler behaviour.

Can someone here explain the needed steps for me to achieve that, or better with some snippet codes, or direct me to a good reference on the internet?

Oh, Please don't tell me to use the "lazy-but-slow way", that is, for loop, I know that.


Solution

  • I've demonstrated how to delete items from a dynamic array before:

    In that article, I start with the following code:

    type
      TXArray = array of X;
    
    procedure DeleteX(var A: TXArray; const Index: Cardinal);
    var
      ALength: Cardinal;
      i: Cardinal;
    begin
      ALength := Length(A);
      Assert(ALength > 0);
      Assert(Index < ALength);
      for i := Index + 1 to ALength - 1 do
        A[i - 1] := A[i];
      SetLength(A, ALength - 1);
    end;
    

    You cannot go wrong with that code. Use whatever value for X you want; in your case, replace it with string. If you want to get fancier and use Move, then there's way to do that, too.

    procedure DeleteX(var A: TXArray; const Index: Cardinal);
    var
      ALength: Cardinal;
      TailElements: Cardinal;
    begin
      ALength := Length(A);
      Assert(ALength > 0);
      Assert(Index < ALength);
      Finalize(A[Index]);
      TailElements := ALength - Index;
      if TailElements > 0 then
        Move(A[Index + 1], A[Index], SizeOf(X) * TailElements);
      Initialize(A[ALength - 1]);
      SetLength(A, ALength - 1);
    end;
    

    Since X is string, the Finalize call is equivalent to assigning the empty string to that array element. I use Finalize in this code, though, because it will work for all array-element types, even types that include records, interfaces, strings, and other arrays.

    For inserting, you just shift things the opposite direction:

    procedure InsertX(var A: TXArray; const Index: Cardinal; const Value: X);
    var
      ALength: Cardinal;
      TailElements: Cardinal;
    begin
      ALength := Length(A);
      Assert(Index <= ALength);
      SetLength(A, ALength + 1);
      Finalize(A[ALength]);
      TailElements := ALength - Index;
      if TailElements > 0 then begin
        Move(A[Index], A[Index + 1], SizeOf(X) * TailElements);
      Initialize(A[Index]);
      A[Index] := Value;
    end;
    

    Use Finalize when you're about to do something that's outside the bounds of the language, such as using the non-type-safe Move procedure to overwrite a variable of a compiler-managed type. Use Initialize when you're re-entering the defined part of the language. (The language defines what happens when an array grows or shrinks with SetLength, but it doesn't define how to copy or delete strings without using a string-assignment statement.)