inkompatibel TArray<Integer> Pointer

[Uwe Raabe]

Zitat von EWeiss:

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 von Uwe Raabe:

Zitat von EWeiss:

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 von EWeiss:

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 von Uwe Raabe:

Zitat von EWeiss:

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 von EWeiss:

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