Appending one element to a dynamic array

Question

The straight-forward way to append one element to a dynamic array is as follows:

SetLength(SomeDynamicArray, Length(SomeDynamicArray) + 1);
SomeDynamicArray[High(SomeDynamicArray)] := NewElement;

Disregarding performance issues due to memory fragmentation, is there a way to do this in one line?

Answer 1

Starting with Delphi XE7 you can do:

SomeDynamicArray := SomeDynamicArray + [NewElement];

ref: Marco Tech Blog, September 18, 2014 : Dynamic Arrays in Delphi XE7

Answer 2

Here's a hack with generics which only works with TArray<T>:

type
  TAppender<T> = class
    class procedure Append(var Arr: TArray<T>; Value: T);
  end;

class procedure TAppender<T>.Append;
begin
  SetLength(Arr, Length(Arr)+1);
  Arr[High(Arr)] := Value;
end;

Usage:

var
  TestArray: TArray<Integer>;

begin
  TAppender<Integer>.Append(TestArray, 5);
end.

Answer 3

Every time you call SetLength the memory gets reallocated. Maybe the entire array needs to be copied to a different location. And you who just wanted to add a single element to the array!

Basically: never do this. There are two ways out of it. The simplest case is if you beforehand know the maximum size of the array:

procedure Example1;
var
  data: array of string;
  ActualLength: integer;

  procedure AddElement(const Str: string);
  begin
    data[ActualLength] := Str;
    inc(ActualLength);
  end;

begin

  ActualLength := 0;
  SetLength(data, KNOWN_UPPER_BOUND);

  for ...
    while ...
      repeat ...
        AddElement(SomeString);

  SetLength(data, ActualLength);

end;

Here is a practial example of this approach.

If you don't know any upper bound a priori, then allocate in large chunks:

procedure Example2;
const
  ALLOC_BY = 1024;
var
  data: array of string;
  ActualLength: integer;

  procedure AddElement(const Str: string);
  begin
    if ActualLength = length(data) then
      SetLength(data, length(data) + ALLOC_BY);

    data[ActualLength] := Str;
    inc(ActualLength);
  end;

begin

  ActualLength := 0;
  SetLength(data, ALLOC_BY);

  for ...
    while ...
      repeat ...
        AddElement(SomeString);

  SetLength(data, ActualLength);

end;

This second approach is implemented in the run-time library's TList<T>, TObjectList<T>, TStringList etc. Hence, when you use these classes, it is perfectly fine to append the list one item at a time.

Answer 4

That's an anti-pattern that results in memory fragmentation. Instead use Generics.Collections.TList<T> and call the Add method to add new items.

There is no one liner to extend an array and add an item. You could create your own dynamic array wrapper using generics to do this should you so desire. Essentially that's what Generics.Collections.TList<T> is.

Answer 5

There is handy Insert procedure, that you can use like this:

Insert([NewElement], SomeDynamicArray, High(SomeDynamicArray));

Answer 6

MyList.Add(myobject);

IMO Dynamic arrays should only be used when at compile time you don't know the exact size of the array but at run time you will know.

If you need to continually manipulate your array size, you shouldn't be using an array but a TList or one of its descendants, as others have mentioned: TObjectList, TInterfaceList, TStringList.Objects[] can all be used (and abused) and there are some new ones as well, and TList for primitive types. TList used to be something of a pain before generics were introduced into Delphi - you had to work with pointers - but with generics: TList <T> it's very easy.

Also, use the capacity property of any list you create - it will pre-allocate the given amount of memory so your code doesn't cause lots of memory to get juggled around every time you perform an operation on your list. (If you go beyond the capacity you allocated, memory manager will give you more memory at runtime- you wan't fail - see Delphi Help)

Answer 7

If you have Delphi 2009 or later, and you really want to shorten the above piece of code, you could try something like

type
  DataArray<T> = record
    Data: array of T;
    procedure Append(const Value: T);
    function Count: integer;
  end;


{ DataArray<T> }

procedure DataArray<T>.Append(const Value: T);
begin
  SetLength(Data, length(Data) + 1);
  Data[high(Data)] := Value;
end;

function DataArray<T>.Count: integer;
begin
  result := length(Data);
end;

Then you can do

procedure TForm1.FormCreate(Sender: TObject);
var
  data: DataArray<string>;
begin
  data.Append('Alpha');
  data.Append('Beta');
  Caption := IntToStr(data.Count) + ': ' data.Data[0] + ' & ' + data.Data[1];
end;

Answer 8

You can simply use this code to append an element to end of any dynamic array. fast and short.

...
var
  myArray: array of Integer;
  element: Integer;
...
Insert(element, myArray, MaxInt);
...