inkompatibel TArray<Integer> Pointer

[EWeiss]

Unter 32 Bit habe ich hier kein Problem..

Delphi-Quellcode:

var
  pXY: PPoint;

meta := Pointer(pXY);

In 64 Bit meckert der Compiler

Zitat:

[dcc64 Error] uSpriteContainer.pas(4481): E2010 Incompatible types: 'System.TArray<System.Integer>' and 'Pointer'

??

anderes Problem

Zitat:

[dcc64 Warning] uSpriteContainer.pas(6299): W1000 Symbol 'Seek' is deprecated

Delphi-Quellcode:

FileStream.Seek(AniHeader.offset - 1, soFromBeginning);

Was nehmen statt dessen ?

gruss

[Uwe Raabe]

Was ist PPoint? Das aus System.Types?

Was ist meta?

Zitat:

Zitat von EWeiss (Beitrag 1409758)

Delphi-Quellcode:

FileStream.Seek(AniHeader.offset - 1, soFromBeginning);

Was nehmen statt dessen ?

Das andere overload:

Delphi-Quellcode:

FileStream.Seek(AniHeader.offset - 1, soBeginning);

[EWeiss]

Zitat:

Was ist PPoint? Das aus System.Types

Ja..

Zitat:

Was ist meta?

Dachte das wäre ersichtlich ;)

Delphi-Quellcode:

TArray<Integer>

gruss

[mkinzler]

Zitat:

anderes Problem
Zitat:
[dcc64 Warning] uSpriteContainer.pas(6299): W1000 Symbol 'Seek' is deprecated
FileStream.Seek(AniHeader.offset - 1, soFromBeginning);
Was nehmen statt dessen ?

Nicht seek ist veraltet nur eine der 3 überladenen Versionen. Komischerweise die mit größeren möglichen Offset (64 Bit).

Delphi-Quellcode:

FileStream.Seek(AniHeader.offset - 1, TSeekOrigin.soFromBeginning);

[EWeiss]

Das funktioniert :) Danke Uwe

Delphi-Quellcode:

FileStream.Seek(AniHeader.offset - 1, soBeginning);

gruss

[Uwe Raabe]

Delphi-Quellcode:

procedure Main;
var
  meta: TArray<Integer>;
  pXY: PPoint;
begin
  meta := Pointer(pXY); // [dcc32 Fehler] Project403.dpr(31): E2010 Inkompatible Typen: 'System.TArray<System.Integer>' und 'Pointer'
end;

Funktioniert hier auch unter Win32 nicht und gibt die gleiche Fehlermeldung.

[EWeiss]

Zitat:

Zitat von Uwe Raabe (Beitrag 1409772)

Delphi-Quellcode:

procedure Main;
var
  meta: TArray<Integer>;
  pXY: PPoint;
begin
  meta := Pointer(pXY); // [dcc32 Fehler] Project403.dpr(31): E2010 Inkompatible Typen: 'System.TArray<System.Integer>' und 'Pointer'
end;

Funktioniert hier auch unter Win32 nicht und gibt die gleiche Fehlermeldung.

Aber mit D2010 hatte bisher nie Probleme damit. (kann nur 32Bit)

gruss

[Uwe Raabe]

Zitat:

Zitat von EWeiss (Beitrag 1409774)

Aber mit D2010 hatte bisher nie Probleme damit.

Dann was das vermutlich ein Fehler in D2010. Eigentlich darf dieser Cast nicht funktionieren. Ein dynamisches Array verwaltet seine Länge und den Referenzzähler in einem Bereich vor dem ersten Element. Bei dem Cast ist vollkommen unklar, was dann in diesem Bereich steht. Das kann eigentlich nur schief gehen.

http://docwiki.embarcadero.com/RADSt...he_Array-Typen

[EWeiss]

Zitat:

Zitat von Uwe Raabe (Beitrag 1409775)

Zitat:

Zitat von EWeiss (Beitrag 1409774)

Aber mit D2010 hatte bisher nie Probleme damit.

Dann was das vermutlich ein Fehler in D2010. Eigentlich darf dieser Cast nicht funktionieren. Ein dynamisches Array verwaltet seine Länge und den Referenzzähler in einem Bereich vor dem ersten Element. Bei dem Cast ist vollkommen unklar, was dann in diesem Bereich steht. Das kann eigentlich nur schief gehen.

http://docwiki.embarcadero.com/RADSt...he_Array-Typen

Ich glaube dir das ;)

Aber bitte siehe shot!
Das es durchläuft ohne Fehler kannst du am aktuellen Breakpoint sehen dieser ist weiter unten.

Delphi-Quellcode:

meta := Pointer(pXY);

dann ist

Delphi-Quellcode:

meta[0] := pXY.X;  
meta[1] := pXY.Y;

gruss

[Uwe Raabe]

Ich weiß ja nicht, wie du pXY zuweist. Wenn das ein Pointer auf das erste Element eines TArray<Integer> ist, dann funktioniert das natürlich, weil dann die betreffenden Speicherbereiche ja sinnvolle Werte beinhalten.

[EWeiss]

Zitat:

Zitat von Uwe Raabe (Beitrag 1409778)

Ich weiß ja nicht, wie du pXY zuweist. Wenn das ein Pointer auf das erste Element eines TArray<Integer> ist, dann funktioniert das natürlich, weil dann die betreffenden Speicherbereiche ja sinnvolle Werte beinhalten.

So!

Delphi-Quellcode:

    xy[0].x := 80  + 110;  xy[0].y := 135 + 50;
    xy[1].x := 140 + 110;  xy[1].y := 130 + 50;
    xy[2].x := 160 + 110;  xy[2].y := 80  + 50;
    xy[3].x := 180 + 110;  xy[3].y := 130 + 50;
    xy[4].X := 240 + 110;  xy[4].y := 135 + 50;
    xy[5].X := 192 + 110;  xy[5].y := 165 + 50;
    xy[6].X := 210 + 110;  xy[6].y := 220 + 50;
    xy[7].X := 160 + 110;  xy[7].y := 190 + 50;
    xy[8].X := 110 + 110;  xy[8].y := 220 + 50;
    xy[9].X := 128 + 110;  xy[9].y := 165 + 50;

Delphi-Quellcode:

    gSprCtrl.GD_DrawPolyLineToCtrl(HSprCtrl, @xy[0], 10,
      gSprCtrl.GD_ColorARGB(255,RGB(100, 250, 150)), 5, ID_POLYLINE,
      GS_VISIBLE or GS_DRAFT, GD_DRAW_OUTLINE, 0);
        gSprCtrl.GD_SetObjectImageLabel(ID_ELLIPSE, 'Polyline');

Siehe @xy[0]..

Delphi-Quellcode:

function TSkinSpriteContainer.GD_DrawPolyLineToCtrl(WinHandle: HWND; pXY: PPoint;
  ArraySize: Integer; ColrARGB: Colorref; BorderSize, ObjID, GS_STYLE, GD_STYLE: DWORD;
  Use3D: Short): BOOL;
begin

  Result := False;

  if (IsWindow(WinHandle)) then
    Result := gDrawPointsObject(OBJECT_POLYLINE, WinHandle, pXY, ArraySize, ColrARGB, BorderSize,
      ObjID, GS_STYLE, GD_STYLE, Use3D);

end;

und..

Delphi-Quellcode:

function TSkinSpriteContainer.gDrawPointsObject(ObjectType: Integer; WinHandle: HWND; pXY: PPoint;
  ArraySize: Integer; ColrARGB: Colorref; BorderSize, ObjID, GS_STYLE, GD_STYLE: DWORD;
  Use3D: Short): BOOL;
var
  ExistItem, Item: Integer;
  x1, y1, x2, y2: Integer;
  Border, K, C: Integer;
  meta: TArray<Integer>;
  pData: Short;
begin
//...

    meta := Pointer(pXY); // funktioniert mit D2010

    x1 := meta[0];
    y1 := meta[1];
    x2 := meta[(ArraySize * 2) - 2];
    y2 := meta[(ArraySize * 2) - 1];

end;

aber wie schon gesagt es geht in D2010 aber nicht mit Tokyo
Ich lasse es erst mal mit der 64Bit Version.. das ist mir echt suspekt das ganze.

Danke..

gruss

[Uwe Raabe]

Nur mal aus Interesse: Wenn es so in D2010 mit der Pointer-Zuweisung funktioniert, was gibt dann Length(meta) zurück?

Gibt es Fälle, wo der Aufruf mit @xy[<Wert größer 0>] erfolgt?

Anhand der Übergabeparameter im ersten Code-Block und der Aussage, daß es funktioniert, schließe ich, daß xy ein TArray<TPoint> ist mit einer Länge von 10 (ArraySize). Das sollte dann auch der oben genannte Wert von Length(meta) sein. Wenn dem so ist, funktioniert dein Code auch noch, wenn du Range-Checking bei der X/Y-Zuweisung im letzten Code-Block einschaltest?

Delphi-Quellcode:

    {$R+}
    x1 := meta[0];
    y1 := meta[1];
    x2 := meta[(ArraySize * 2) - 2];
    y2 := meta[(ArraySize * 2) - 1];

Gibt es einen Grund, warum meta nicht auch als TArray<TPoint> deklariert ist?

[EWeiss]

Zitat:

daß xy ein TArray<TPoint> ist mit einer Länge von 10 (ArraySize).

Richtig!
Nein.

Delphi-Quellcode:

xy: array [0..9] of TPoint;

Siehe edit.. im vorherigen Beitrag.

Zitat:

Wenn dem so ist, funktioniert dein Code auch noch, wenn du Range-Checking bei der X/Y-Zuweisung im letzten Code-Block einschaltest?

Werde ich mal prüfen.

EDIT:
Ja funktioniert.

gruss

[Uwe Raabe]

Zitat:

Zitat von EWeiss (Beitrag 1409781)

Ja funktioniert.

Interessant! Ich bekomme bei dem folgenden Code, der im Wesentlichen eine Essenz des oben gezeigten ist, unter D2010 einen RangeError:

Delphi-Quellcode:

procedure Main;
var
  ArraySize: Integer;
  xy: TArray<TPoint>;
  meta: TArray<Integer>;
  pXY: PPoint;
  x1: Integer;
  x2: Integer;
  y1: Integer;
  y2: Integer;
begin
  SetLength(xy, 10);
  xy[0].x := 80 + 110; xy[0].y := 135 + 50;
  xy[1].x := 140 + 110; xy[1].y := 130 + 50;
  xy[2].x := 160 + 110; xy[2].y := 80 + 50;
  xy[3].x := 180 + 110; xy[3].y := 130 + 50;
  xy[4].X := 240 + 110; xy[4].y := 135 + 50;
  xy[5].X := 192 + 110; xy[5].y := 165 + 50;
  xy[6].X := 210 + 110; xy[6].y := 220 + 50;
  xy[7].X := 160 + 110; xy[7].y := 190 + 50;
  xy[8].X := 110 + 110; xy[8].y := 220 + 50;
  xy[9].X := 128 + 110; xy[9].y := 165 + 50;
  ArraySize := 10;
  pXY := @xy[0];
  meta := Pointer(pXY);
  {$R+}
  x1 := meta[0];
  y1 := meta[1];
  x2 := meta[(ArraySize * 2) - 2]; // <== ERangeError
  y2 := meta[(ArraySize * 2) - 1];
  Writeln(x1, y1, x2, y2);
end;

[EWeiss]

Ich bekomme keinen ERangeError mit {$R+}
Kann dir nur mitteilen was hier abgeht. Siehe Range.png der Breakpoint steht auf C.. also hinter deinem ERangeError.
Und die Anwendung funktioniert kannst mir glauben ;)

Ich zeichne den Stern damit.

Delphi-Quellcode:

xy: TArray<TPoint>;

ist falsch muss

Delphi-Quellcode:

xy: array [0..9] of TPoint;

sein.

Aber wie du sehen kannst scheint

Delphi-Quellcode:

meta := Pointer(pXY);

bei dir auch zu funktionieren nur halt in Tokjo nicht.

Nun! Was ist nun falsch Tokjo oder D2010
Ich kann unter Tokjo diese Zeile nicht Kompilieren wegen besagten Fehler.. und die kommt öfters vor.

gruss

[Uwe Raabe]

Zitat:

Zitat von EWeiss (Beitrag 1409783)

Delphi-Quellcode:

xy: TArray<TPoint>;

ist falsch muss

Delphi-Quellcode:

xy: array [0..9] of TPoint;

sein.

Das ist der entscheidende Unterschied. Damit sind die Werte für Länge und Referenzzähler des Arrays undefiniert bzw. von den davor liegenden Daten abhängig. Ein Length(meta) sollte demnach auch einen zufälligen Wert zurückgeben. Du sitzt damit potentiell quasi auf einer Zeitbombe.

[EWeiss]

Zitat:

Ein Length(meta) sollte demnach auch einen zufälligen Wert zurückgeben

Da muss ich dir recht geben.

Zitat:

Du sitzt damit potentiell quasi auf einer Zeitbombe.

Hmm.. wie ist es richtig? bzw. es löst immer noch nicht das Problem mit Tokjo.

TArray<TPoint> ?

Nur dann denke ich bekomme ich ebenfalls den Range Error.

Kann ich ändern sollte kein Problem sein.

Delphi-Quellcode:

GD_DrawPolyLineToCtrl(WinHandle: HWND; pXY: TArray[TPoint>;
   ArraySize: Integer; ColrARGB: Colorref; BorderSize, ObjID, GS_STYLE, GD_STYLE: DWORD;
   Use3D: Short): BOOL;

Das

Delphi-Quellcode:

x2 := meta[(ArraySize * 2) - 2];
//zu
x2 := meta[ArraySize - 2];

werde das nochmal testen.. Danke.

gruss

[Uwe Raabe]

Ich würde einen Open Array Parameter verwenden. Das ArraySize kannst du dir dann auch sparen und mit Length(arrXY) ersetzen.

Delphi-Quellcode:

GD_DrawPolyLineToCtrl(WinHandle: HWND; const arrXY: array of TPoint;
   ColrARGB: Colorref; BorderSize, ObjID, GS_STYLE, GD_STYLE: DWORD;
   Use3D: Short): BOOL;

[EWeiss]

Zitat:

Zitat von Uwe Raabe (Beitrag 1409786)

Ich würde einen Open Array Parameter verwenden. Das ArraySize kannst du dir dann auch sparen und mit Length(arrXY) ersetzen.

Delphi-Quellcode:

GD_DrawPolyLineToCtrl(WinHandle: HWND; const arrXY: array of TPoint;
   ColrARGB: Colorref; BorderSize, ObjID, GS_STYLE, GD_STYLE: DWORD;
   Use3D: Short): BOOL;

Ok werde es mal umsetzen ;)

gruss

[EWeiss]

Zitat:

Das ArraySize kannst du dir dann auch sparen und mit Length(arrXY) ersetzen.

Nun ja das ArraySize muss ich behalten..
Aus folgenden Grund.

x und y haben jeweils 10 einträge..

Delphi-Quellcode:

var
  xy: array of TPoint;

  begin
    SetLength(xy, 20);

    xy[0].x := 190;  xy[0].y := 185;
    xy[1].x := 250;  xy[1].y := 180;
    xy[2].x := 270;  xy[2].y := 130;
    xy[3].x := 290;  xy[3].y := 180;
    xy[4].X := 350;  xy[4].y := 185;
    xy[5].X := 302;  xy[5].y := 215;
    xy[6].X := 320;  xy[6].y := 270;
    xy[7].X := 270;  xy[7].y := 240;
    xy[8].X := 220;  xy[8].y := 270;
    xy[9].X := 238;  xy[9].y := 210;

    gSprCtrl.GD_DrawPolyLineToCtrl(HSprCtrl, xy[0], 10,
      gSprCtrl.GD_ColorARGB(255,RGB(100, 250, 150)), 5, ID_POLYLINE,
      GS_VISIBLE or GS_DRAFT, GD_DRAW_OUTLINE, 0);
    
    gSprCtrl.GD_SetObjectImageLabel(ID_ELLIPSE, 'Polyline');
  end;

diese werden in der DLL auf diese weise ausgewertet.

Delphi-Quellcode:

    C := 0;
    for K := 0 to (ArraySize - 1) do
    begin
      x1 := min(x1, meta[C]);
      x2 := max(x2, meta[C]);
      inc(C);

      y1 := min(y1, meta[C]);
      y2 := max(y2, meta[C]);
      inc(C);
    end;

Somit muss die länge von ArraySize die hälfte sein.
Meta wird dann so zugewiesen.

Delphi-Quellcode:

meta := @pXY;

Ob das jetzt mit 64Bit kompatibel ist muss ich erst noch testen, glaube aber nicht!
Meine Frage ist also immer noch nicht beantwortet trotz der fixes ;) Danke nochmal für die Infos.
D2010 funktioniert.

gruss

[Uwe Raabe]

Zitat:

Zitat von EWeiss (Beitrag 1409790)

Nun ja das ArraySize muss ich behalten..
Aus folgenden Grund.

x und y haben jeweils 10 einträge..

Ja, und das Array hat 10 Elemente, wobei jedes Element einen X und einen Y Wert hat. Deshalb ist die Länge des Arrays eben 10 und nicht 20.

[EWeiss]

Zitat:

Zitat von Uwe Raabe (Beitrag 1409801)

Zitat:

Zitat von EWeiss (Beitrag 1409790)

Nun ja das ArraySize muss ich behalten..
Aus folgenden Grund.

x und y haben jeweils 10 einträge..

Ja, und das Array hat 10 Elemente, wobei jedes Element einen X und einen Y Wert hat. Deshalb ist die Länge des Arrays eben 10 und nicht 20.

Ich muss die länge von xy auf 20 festlegen weil ich sonst bei meiner Berechnung einen ERangeError bekomme.
SetLength(xy, 20);
eventuell reden wir an einander vorbei.

Zitat:

Deshalb ist die Länge des Arrays eben 10 und nicht 20.

die Länge des meta Arrays ist 20 nicht 10

gruss

[Uwe Raabe]

Zitat:

Zitat von EWeiss (Beitrag 1409802)

die Länge des meta Arrays ist 20 nicht 10

Brauchst du das Meta-Array überhaupt noch, wenn du ja jetzt Zugriff auf das originale hast? Dann fällt das ganze Gepointere und Gecaste weg und du hast keine Probleme mit x64.

[EWeiss]

Zitat:

Zitat von Uwe Raabe (Beitrag 1409805)

Zitat:

Zitat von EWeiss (Beitrag 1409802)

die Länge des meta Arrays ist 20 nicht 10

Brauchst du das Meta-Array überhaupt noch, wenn du ja jetzt Zugriff auf das originale hast? Dann fällt das ganze Gepointere und Gecaste weg und du hast keine Probleme mit x64.

Jo das brauche ich.
Ich habe keine zugriff auf das Original das ist ja mein Problem.

gruss

[Uwe Raabe]

Zitat:

Zitat von EWeiss (Beitrag 1409806)

Ich habe keine zugriff auf das Original das ist ja mein Problem.

In meinem Beispiel wird das Original im Parameter arrXY übergeben und kann in der Prozedur zumindest lesend verwendet werden. Wenn du das Original verändern willst, muss der Parameter anderes deklariert werden.

[EWeiss]

Dein Beispiel!

Delphi-Quellcode:

procedure Main;
var
   ArraySize: Integer;
   xy: TArray<TPoint>;
   meta: TArray<Integer>;
   pXY: PPoint;
   x1: Integer;
   x2: Integer;
   y1: Integer;
   y2: Integer;
begin
   SetLength(xy, 10);
   xy[0].x := 80 + 110; xy[0].y := 135 + 50;
   xy[1].x := 140 + 110; xy[1].y := 130 + 50;
   xy[2].x := 160 + 110; xy[2].y := 80 + 50;
   xy[3].x := 180 + 110; xy[3].y := 130 + 50;
   xy[4].X := 240 + 110; xy[4].y := 135 + 50;
   xy[5].X := 192 + 110; xy[5].y := 165 + 50;
   xy[6].X := 210 + 110; xy[6].y := 220 + 50;
   xy[7].X := 160 + 110; xy[7].y := 190 + 50;
   xy[8].X := 110 + 110; xy[8].y := 220 + 50;
   xy[9].X := 128 + 110; xy[9].y := 165 + 50;
   ArraySize := 10;
   pXY := @xy[0];
   meta := Pointer(pXY);
   {$R+}
   x1 := meta[0];
   y1 := meta[1];
   x2 := meta[(ArraySize * 2) - 2]; // <== ERangeError
   y2 := meta[(ArraySize * 2) - 1];
   Writeln(x1, y1, x2, y2);
end;

Warum hast du hier einen ERangeError?
Genau, weil du dein Array mit einer länge von 10 definiert hast es muss aber 20 sein.

Teste es einfach mal.
Setze einen Breakpoint auf x1 := meta[0];
Und prüfe welche werte meta dann hat wenn du 20 als länge übergibst.

Nur mit 20 hast du alle werte und zwar die von xy[0].x + xy[0].y das wären jetzt schon 2

Und genau das ist mein Problem denn eigentlich möchte ich auch das es mit einer länge von 10 funktioniert.
Geht aber nicht weil meta TArray<integer> ist! Mit TPoint funktioniert es nicht so recht.

Deshalb muss ich jeden einzelnen wert x, y als Integer an meta übergeben und das sind nun mal 20 nicht 10
Ich caste quasi ein TPoint in ein Integer Array weil 1 Array of TPoint nun mal 2 werte hat müssen diese mit 10 Multipliziert werden.

gruss

[Uwe Raabe]

OK, dann bleibst du am besten bei deinem Code, wenn es für dich so funktioniert.

[EWeiss]

Ja Danke..

Dein Hinweis TPoint als Array auszulegen war ja korrekt nur die länge halt nicht.
So sieht es aus!
Bilder sagen mehr als 1000 Worte. Wenn du dir die Berechnung genau ansiehst wirst du erkennen warum es bei dir kracht!
Siehe inc(C)

Der Unterschied ist dieser..
meta: TArray<TPoint> length 10
meta: TArray<Integer> length 20 weil TPoint 2 Werte enthält.

Ich caste TPoint in einen Array of Integer deshalb muss ich zwingend die länge des TPoint Array mit 20 festlegen.
Ja ist ungewöhnlich!

Mit 64Bit geht es nicht.. weil der Compiler bei D2010 oder aber in Tokyo verrückt spielt.
Eines der beiden Produkte hat ein Problem.

gruss

[Fritzew]

Dein casten zu TArray<integer> ist definitiv falsch! Du hast kein Tarray<Integer>


Das funktioniert unter 32 und 64 Bit:

Delphi-Quellcode:

const
  maxIntArraysize = (maxint-sizeof(integer)) div sizeof(integer);

 type
  IntArray = Array [0.. maxIntArraysize] of integer;
  PIntArray = ^IntArray;

 procedure Main;
var
   ArraySize: Integer;
   xy: TArray<TPoint>;
   meta: PIntArray;

   pXY: PPoint;
   x1: Integer;
   x2: Integer;
   y1: Integer;
   y2: Integer;
begin
   writeln('Sizeof TPoint ', sizeof(Tpoint));
   writeln('Sizeof Integer ', sizeof(Integer));

   SetLength(xy, 10);
   xy[0].x := 80 + 110; xy[0].y := 135 + 50;
   xy[1].x := 140 + 110; xy[1].y := 130 + 50;
   xy[2].x := 160 + 110; xy[2].y := 80 + 50;
   xy[3].x := 180 + 110; xy[3].y := 130 + 50;
   xy[4].X := 240 + 110; xy[4].y := 135 + 50;
   xy[5].X := 192 + 110; xy[5].y := 165 + 50;
   xy[6].X := 210 + 110; xy[6].y := 220 + 50;
   xy[7].X := 160 + 110; xy[7].y := 190 + 50;
   xy[8].X := 110 + 110; xy[8].y := 220 + 50;
   xy[9].X := 128 + 110; xy[9].y := 165 + 50;

   Writeln('ArraySize Points ', length(xy));
   // Length of integer Array
   ArraySize := length(xy) *2;
   Writeln('ArraySize integer ', ArraySize);
   pXY := @xy[0];
   meta := Pointer(pXY);
   {$R+}
   x1 := meta[0];
   y1 := meta[1];

   x2 := meta[ArraySize - 2];
   y2 := meta[ArraySize - 1];
   Writeln(x1:6, y1:6, x2:6, y2:6);
end;

[EWeiss]

Zitat:

Du hast kein Tarray<Integer>

Klar habe ich eins.

meta: TArray<Integer>;

und so geht's.

Delphi-Quellcode:

    meta := @pXY;
    SetLength(meta, ArraySize * 2);

    x1 := meta[0];
    y1 := meta[1];
    x2 := meta[(ArraySize * 2) - 2];
    y2 := meta[(ArraySize * 2) - 1];

    C := 0;
    for K := 0 to (ArraySize - 1) do
    begin
      x1 := min(x1, meta[C]);
      x2 := max(x2, meta[C]);
      inc(C);

      y1 := min(y1, meta[C]);
      y2 := max(y2, meta[C]);
      inc(C);
    end;

gruss

[Fritzew]

Ja was den nun?
Pointer auf das Array oder neu erzeugt?

Delphi-Quellcode:

 meta := @pXY; //Pointer
  SetLength(meta, ArraySize * 2); //Neu

Ein TArray<t> ist etwas anderes als ein klassisches Array [0..n] of t

Und warum musst Du überhaupt casten?

Delphi-Quellcode:

for K := 0 to (ArraySize - 1) do
    begin
      x1 := min(x1, xy[k].x);
      x2 := max(x2, xy[k].x);
      y1 := min(y1, xy[k].y);
      y2 := max(y2, xy[k].y);
    end;

Aber nun gut........

[EWeiss]

Zitat:

SetLength(meta, ArraySize * 2); //Neu

Der Inhalt von meta bleibt ja erhalte ich setze nur die neue länge.
Neu erzeugt wird da gar nichts.

Anbei zwei shots.. Du siehst also die Daten sind Korrekt.

Zitat:

Und warum musst Du überhaupt casten?

Ganz einfach weil ich ein TArray<Integer> definiert habe und nicht TArray<TPoint>;

Aber werde deine Variante mal testen. Danke!

gruss

[EWeiss]

@Fritzew

Danke für deine Variante habe sie übernommen aber nur den Teil.

Delphi-Quellcode:

const
   maxIntArraysize = (maxint-sizeof(integer)) div sizeof(integer);

  type
   IntArray = Array [0.. maxIntArraysize] of integer;
   PIntArray = ^IntArray;

meta: PIntArray;

Das Ergebnis ist das gleiche aber kompatibler und ohne unnötiges casten.
Nochmals Danke schön :)

gruss