TArray - Alternative zu SetLength(..) ?

[Der schöne Günther]

Ich möchte ein Array erstellen, und das soll bitte x Stellen breit sein. Jeder vernünftige Mensch geht, bei bspw. fünf Stellen hin und sagt

Delphi-Quellcode:

var
   myArray: TArray<Boolean>;
begin
   myArray := TArray<Boolean>.Create();
   SetLength(myArray, 5);
   [...]
end

Meine Motivation ist, dass ich gerne eine Kollektion (wie eine Liste) hätte, und die soll bitte direkt vom Start weg eine bestimmte Länge haben. Ja, man kann hingehen, und nacheinander die beliebige Menge an Elementen hinzufügen.

Wäre es nicht viel eleganter, wenn man "anonym" ein Array mit gleich einer bestimmten Länge erzeugen kann und das Parameter für dem Copy-Konstruktor nimmt?

Delphi-Quellcode:

uses Spring.Collections;
var
   myBooleanList: IList<Boolean>;
begin
   myBooleanList := TCollections.CreateList<Boolean>(
      TArray<Boolean>.Create(False, False, False, False, False)
   );
end;

Das ist schon nahe dran, allerdings muss ich hier die Elemente im Array alle einzeln auflisten. Ich suche also im Endeffekt einen "Konstruktor" für ein Array das mich nicht die Elemente einzeln auflisten lässt, sondern im Endeffekt nur ein

Delphi-Quellcode:

SetLength(..)

macht- Also nur die Anzahl der mit Default-Wert initialisierten Elemente entgegennimmt.

Gibt es da was feines?

[Uwe Raabe]

Bei einem TArray<T> brauchst du den Konstruktor doch gar nicht:

Delphi-Quellcode:

var
   myArray: TArray<Boolean>;
begin
   SetLength(myArray, 5);
   [...]
end

[Mavarik]

Zitat:

Zitat von Der schöne Günther (Beitrag 1249395)

Jeder vernünftige Mensch geht, bei bspw. fünf Stellen hin und sagt

Delphi-Quellcode:

var
   myArray: TArray<Boolean>;
begin
   myArray := TArray<Boolean>.Create();
   SetLength(myArray, 5);
   [...]
end

[/Delphi]

Jeder vernünftige Mensch... LOL

wir wäre es mit

Delphi-Quellcode:

var
   MyArray : Array[0..4] of Boolean;

Ich dachte so machen das vernünftige Menschen... :stupid:

OK Spass beiseite.

Kannst Du mal erklären wofür und was Du vor hast?

Mavarik

[Der schöne Günther]

Ich möchte eine Liste anlegen. Beispielsweise die Standard RTL-Liste

Delphi-Quellcode:

System.Generics.Collections.TList

. Oder eine

Delphi-Quellcode:

Spring.Collections.IList

.

Diese Liste soll vom Start weg 20 Einträge haben. Booleans, Floats, irgendwas.

Das sieht dann so aus

Delphi-Quellcode:

uses System.Generics.Collections;
const
   numItems:       Integer =   20;
   stdItemValue:    Integer =   0;
var
   myList: TList<Integer>;
   itemNo: Integer;
begin
   myList := TList<Integer>.Create();
   
   for itemNo := 0 to Pred(numItems) do
      myList.Add(stdItemValue);
      
end;

Ich denke, das geht besser. Einer Liste kann man bspw. schön sagen "Füge alle Einträge dieses Arrays hinzu":

Delphi-Quellcode:

uses System.Generics.Collections;
const
   numItems:      Integer =   20;
   stdItemValue:   Integer =   0;
var
   myArray:   TArray<Integer>;
   myList:     TList<Integer>;

   itemNo:    Integer;
begin

   // Array erstellen und füllen
   myArray := TArray<Integer>.Create();
   SetLength(myArray, numItems);

   for itemNo := 0 to Pred(numItems) do
      myArray[itemNo] := stdItemValue;

   // Liste aus Array erstellen
   myList := TList<Integer>.Create();
   myList.AddRange(myArray);

   // Mit Spring.Collections.IList ginge auch
   // myList := TCollections.CreateList<Integer>(myArray);

end;

Und ich habe das Gefühl, in der Richtung lässt sich das arg zusammenkürzen. Wenn absolut feststeht, dass es immer fünf Elemente sind, kann ich, dank

Delphi-Quellcode:

TArray<>

ja schon den hier machen:

Delphi-Quellcode:

myList.AddRange( TArray<Integer>.Create(0, 0, 0, 0, 0) );

.

Ich hätte jetzt gerne eine Art

Delphi-Quellcode:

TArray<Integer>.Create(elementCount: Integer)

.


Die erste Idee war, einfach einen Record Helper für [Delphi]TArray<T>[/Delphi zu basteln, aber Helferklassen dürfen anscheinend nicht generisch sein.

Während ich das hier tippe fiel mir die nie genutzte, nicht generische Klasse

Delphi-Quellcode:

TArray

aus

Delphi-Quellcode:

System.Generics.Collections

ein:
Wenn ich mir eine winzige Helferklasse mit

Delphi-Quellcode:

   TArrayHelper = class helper for System.Generics.Collections.TArray
      class function CreateArray<T>(const itemCount: Integer): TArray<T>;
   end;

baue kann ich eigentlich schon relativ zufrieden sein. Jetzt kann ich einfach sagen

Delphi-Quellcode:

myList.AddRange( TArray.CreateArray<Integer>(12345) );

bzw.

Delphi-Quellcode:

myList := TCollections.CreateList<Integer>( TArray.CreateArray<Integer>(5) );

Genau das wollte ich. Auch wenn es schon an den Rand des noch komfortabel lesbaren kommt.

[sx2008]

Zitat:

Zitat von Der schöne Günther (Beitrag 1249395)

... dass ich gerne eine Kollektion (wie eine Liste) hätte

Collections braucht man in Delphi nur, wenn man die Collection im Objektinspektor editieren möchte (oder den Persistenzmechanismus von Delphi ausnützen möchte).
Damit ist das Anwendungsgebiet von Collections die Komponentenentwicklung.

Um eine hohe Anzahl von Booleans speichersparend zu verwalten eignet sich die Klasse TBits.

[Der schöne Günther]

Ich habe weder eine "hohe Anzahl", noch muss ich dringend Speicher sparen. Ist doch nicht verboten, seine Booleans in eine Liste zu packen?

[Furtbichler]

Delphi-Quellcode:

Const
  MyList : Array [0..4] Of Boolean = (false,true,false,true,false);

Ist zwar nur ein Array, aber immerhin.

[Jonas Shinaniganz]

Zitat:

Ich hätte jetzt gerne eine Art TArray<Integer>.Create(elementCount: Integer) .

Dann schreib dir doch so einen Klasse.

Delphi-Quellcode:

uses System.Generics.Collections;

TMyList<T> = class TList<T>
...
constructor Create(T...; Elements : Integer)


begin
    inherited Create(T...);
    
    for itemNo := 0 to Pred(Elements) do
       Add(X);
end;

??

[TiGü]

Zitat:

Zitat von Der schöne Günther (Beitrag 1249395)

Ich möchte ein Array erstellen, und das soll bitte x Stellen breit sein.

Meine Motivation ist, dass ich gerne eine Kollektion (wie eine Liste) hätte, und die soll bitte direkt vom Start weg eine bestimmte Länge haben.

Du möchtest "reservieren"?

Delphi-Quellcode:

var
  MyList : TList<Boolean>;
begin
  MyList := TList<Boolean>.Create;
  MyList.Capacity := 20; // jetzt sind 20 Elemente drin, in diesem Fall ist der Wert der Items gleich false
  MyList.Free;
end;

Aus dem Debugger:

Code:

MyList   ((False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False), 0, Pointer($666A2C) as {System.Generics.Defaults}IComparer<System.Boolean>, (nil,nil), $2A42880)

[Furtbichler]

Günthers lustige Ratestunde.