Delphi array-Initialisierung

Momentan habe ich diese, und es nervt:

type TpointArray = array [0..3] of Tpoint;

class function rotationTable.offsets(pType, rotState, dir: integer): TpointArray;
begin

  Result[0] := point(1, 1);
  Result[1] := point(1, 2);
  Result[2] := point(1, 1);
  Result[3] := point(1, 1);
end;

aber stattdessen ich will etwas wie das hier tun:

class function rotationTable.offsets(pType, rotState, dir: integer): TpointArray;
begin
   Result := [Point(1,1), Point(1,2), Point(1,1), Point(1,1)];
end;

Jedoch auf der Zusammenstellung wird, beschwert es sich, dass die [1, 2, 3, 4] syntax funktioniert nur für ganze zahlen.

Gibt es eine Möglichkeit zu instanziieren/initialisieren ein array of Tpoint ähnlich der Art, wie ich will?

InformationsquelleAutor der Frage Alex O | 2010-02-20

Arrays von records intialised in const-Ausdrücke:

const
  Points : TPointArray = ((X: 1; Y: 1), (X:1; Y:2), (X:1; Y:1), (X:1; Y:1));

class function rotationTable.offsets(pType, rotState, dir: integer): TpointArray;
begin
   Result := Points;
end;

In XE7 ist es möglich, füllen Sie ein dynamisches array von records wie diese:

function GetPointArray: TArray<TPoint>;
begin
  Result := [Point(1,1),Point(1,2),Point(1,1),Point(1,1)];
end;

InformationsquelleAutor der Antwort Gerry Coll

9

Plainth Antwort zeigt den Konstruktor-syntax wie für dynamische arrays. Sie können direkt auf einer TPoint-array liefern eine viel einfachere Hilfsfunktion:
```
type
  TPointDynArray = array of TPoint;
  T4PointArray = array[0..3] of TPoint;

function PointDynArrayTo4PointArray(const input: TPointDynArray): T4PointArray;
var
  i: Integer;
begin
  Assert(Length(input) = Length(Result));
  for i := 0 to High(input) do
    Result[i] := input[i];
end;

class function rotationTable.offsets(pType, rotState, dir: integer): T4PointArray;
begin
  // New dynamic-array-constructor syntax here
  Result := PointDynArrayTo4PointArray(TPointDynArray.Create(
    Point(1,1), Point(1,2), Point(1,1), Point(1,1)));
end;
```
Aber das ist overkill. Delphi können Sie auch definieren, öffnen arrays inline, und es gibt keine zusätzlichen Konstruktor-Aufruf zu schreiben. Das Ergebnis verwendet Ihre ursprünglichen vorgeschlagenen syntax, aber mit dem array verpackt in einer Funktion aufrufen. Es funktioniert in allen Delphi-Versionen, während die "Anlegen" - syntax ist Recht neu.
```
function PointOpenArrayTo4PointArray(const input: array of TPoint): T4PointArray;
var
  i: Integer;
begin
  Assert(Length(input) = Length(Result));
  for i := 0 to High(input) do
    Result[i] := input[i];
end;

class function rotationTable.offsets(pType, rotState, dir: integer): T4PointArray;
begin
  Result := PointOpenArrayTo4PointArray(
    [Point(1,1), Point(1,2), Point(1,1), Point(1,1)]);
end;
```
Möchten Sie vielleicht zu prüfen, mit Gerry ' s Antwort nur, um Ihre arrays von Punkten aussagekräftige Namen, die vielleicht helfen bei der Fehlersuche und eine der acht magischen zahlen in diesen Punkt Definitionen ist falsch.

Schließlich, ein Hinweis auf das, was Delphi meinte, als er sagte, "der [1, 2, 3, 4] syntax funktioniert nur für ganze zahlen." Die syntax definiert eine setund nicht ein array. Man kann nicht eine Reihe von Datensatz-Werte, aber Sie kann haben eine Menge der ganzen zahlen. Ein Nebeneffekt ist, dass die syntax für eine Reihe von Integer-zahlen ist die gleiche wie die syntax für ein offenes array von ganzen zahlen. Ich denke, dass Delphi verwendet Kontext, um herauszufinden, was Sie bedeuten, aber es kann manchmal denke falsch.

InformationsquelleAutor der Antwort Rob Kennedy
4

Können Sie nicht, weil Sie nicht Ausdrücken können, im code-Körper einen Punkt in der Art und Weise, in der Sie sich Ausdrücken können in der const Abschnitt.

Jedoch können Sie einige tricks, um Ihr Leben einfacher, vor allem, wenn Sie eine angemessene Anzahl von Punkten.

Implementieren Sie ein einfaches Verfahren, wie dies (code nicht getestet):
```
procedure BlendDimensions(aXArray, aYArray: TIntegerDynArray; var aResult: TPointArray);
var
  nCount: integer;
  i: integer;

begin
  nCount:=High(aXArray);
  if nCount <> High(aYArray) then 
    Exception.Create('The two dimension arrays must have the same number of elements!');

  SetLength(aResult, nCount);
  for i:=0 to nCount do
  begin
    aResult[i].X:=aXArray[i]; //simple copy
    aResult[i].y:=aYArray[i];
  end;
end;
```
...wo TIntegerDynArray ist die RTL dynamisches array von Ganzzahlen. (In der Tat, es funktioniert mit jedem dynamischen Arrays). Auch, TPointArray im obigen Beispiel ist auch dynamisch.

So, in Ordnung, Ihre Arbeit zu tun, die Sie tun können, wie diese:
```
procedure Foo;
var
  myXCoords, myYCoords: TIntegerDynArray; //temp arrays
  myPoints: TPointArray; //this is the real thing

begin
  myXCoords:=TIntegerDynArray.Create( 1, 2, 3, 4, 5, 6, 7, 8, 9,10);
  myYCoords:=TIntegerDynArray.Create(21,32,34,44,55,66,65,77,88,92); //...for example 
  BlendDimensions(myXCoords, myYCoords, myPoints); //build the real thing
 //use it...
end;
```
Dinge zu beachten:
- Sie deutlich sehen, die sind Ihre Punkte
- Sie können sehr produktiv in dieser Weise
- Können Sie BlendDimensions auch auf andere Dinge, nicht nur auf diesen einen
- Sie können problemlos erweitern BlendDimensions für 3 (oder mehr) Dimensionen
- ...aber Vorsicht, denn eine Kopie ist beteiligt. 🙂 Mit den heutigen PCs, die weakpoint werden, von weit, Ihre hand. 🙂 Sie wird müde werden, geben Sie viel schneller, bis die Kopie Zeit auch aufgefallen.
HTH

InformationsquelleAutor der Antwort John Thomas

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.