Zeiger auf eine Klasse

[Tenobaal]

Hallo, ich schreibe ein Programm zum Speichern von Geometrien diverser Motoren.
Die Koordinaten um die Geometrie eines Motors zu beschrieben sollen mit der Klasse TPoints gespeichert werden.
TPoints besteht aus einem zweidimensionalen dyn. Array mit X-Y-Koordinaten.

Im Programm gibt es später mehrere Instanzen von TPoints, weshalb ich mit Zeigern arbeiten wollte, um auf die gespeicherten X-Y-Koordinaten zuzugreifen.
Zu diesem Zweck habe ich einen Zeiger "Ptr:^TPoints" der auf die jeweilige Instanz von TPoints zeigen soll. Leider funktioniert es überhaupt nicht

Delphi-Quellcode:

//...
type TCoord_XY = record //Speichert eine X-Y-Koordinate
  x,y:Double;
end;

type TPoints = Array of Array of TCoord_XY; //Enthält eine Geometrie aus X-Y-Koordinaten

//...

procedure TForm1.FormCreate(Sender: TObject);
var PointsRotor: TPoints; Ptr:^TPoints;
begin
SetLength(PointsRotor,2,3); //Setze Größe des Arrays direkt
Ptr:=@PointsRotor;
SetLength(Ptr,2,3); //Setze die Größe des Arrays über Pointer... Compiler Fehler
end;

[mkinzler]

Ein Record/Array ist keine Klasse.
Erzeuge dir besser einen Pointertyp

Delphi-Quellcode:

type 
    PPoints = ^TPoints;
    TPoints = Array of Array of TCoord_XY; //Enthält eine Geometrie aus X-Y-Koordinaten

[Namenloser]

Ein Pointer auf dynamische Arrays ist keine gute Idee, denn das dynamische Array ist selbst schon ein Pointer.

Lass den Pointer einfach weg – du kannst auch mehrere Variablen haben, die auf dasselbe Array verweisen. Bei Zuweisungen wird nur der Pointer kopiert, nicht das Array.

Falls du doch mal ein dynamisches Array kopieren willst, musst du Copy aufrufen.

[Tenobaal]

Danke für eure Hilfe.
Ich habe jetzt mehrere Varianten probiert und habe festgestellt, dass ich in obigen Beispiel nur einen Syntaxfehler hatte

@NamenLozer: Nach deiner Meinung sollte ich Variante 3 nehmen (siehe Code), oder? In Bezug auf die Performance ist diese Variante doch schlecht, weil das komplette Array nochmals kopiert werden muss.
Edit: Variante 1 und 2 hingegen verändern direkt den Inhalt von "PointsRotor" ohne zusätzlichen kopiervorgang.

Delphi-Quellcode:

//....

type TCoord_XY = record
  x,y:Double;
end;

type TPoints = Array of Array of TCoord_XY;
     PPoints = ^TPoints;
var
  Form1: TForm1;

//....

procedure TForm1.FormCreate(Sender: TObject);
var PointsRotor: TPoints;
    Ptr:PPoints;
    Ptr2:^TPoints;
    Ptr3:TPoints;
begin
SetLength(PointsRotor, 1,1); //Setze Größe des Arrays direkt
PointsRotor[0,0].x:=1; //Schreibe was in das Array...

//Variante 1
Ptr:=@PointsRotor;
SetLength(Ptr^, 2,1);

//Variante 2
Ptr2:=@PointsRotor;
SetLength(Ptr2^,3,1);

//Variante 3
Ptr3:=PointsRotor;
SetLength(Ptr3,4,1);
PointsRotor:=Copy(Ptr3,Low(Ptr3),High(Ptr3)+1);
end;

[Insider2004]

Zur Info: Als Delphi von Anders aufgesetzt wurde, wählte er das "Zeigerlose Konzept". Deswegen brauchst Du auch keine Zeiger. Aber Du arbeitest ständig damit.

[mkinzler]

Klassen sind Referenzen ( intern auch Zeiger) und Erleichtern den Umgang, da sie das Referenzieren/Dereferenzieren transparent durchführen ( geht z.T. auch bei Zeigertypen). Delphi ist aber trotzdem nicht zeigerlos, da das nur für Klassen gilt.

[Namenloser]

Zitat von Tenobaal:

Danke für eure Hilfe.
Ich habe jetzt mehrere Varianten probiert und habe festgestellt, dass ich in obigen Beispiel nur einen Syntaxfehler hatte

@NamenLozer: Nach deiner Meinung sollte ich Variante 3 nehmen (siehe Code), oder? In Bezug auf die Performance ist diese Variante doch schlecht, weil das komplette Array nochmals kopiert werden muss.
Edit: Variante 1 und 2 hingegen verändern direkt den Inhalt von "PointsRotor" ohne zusätzlichen kopiervorgang.

Du hast mich wohl missverstanden.

Delphi-Quellcode:

var
  A,B: array of integer;
begin
  SetLength(A, 3);
  A[0] := 1;
  A[1] := 2;
  A[2] := 3;

  writeln('A: ', A[0], ', ', A[1], ', ', A[2]);
  // => A: 1, 2, 3

  // REFERENZ
  B := A;

  writeln('B: ', B[0], ', ', B[1], ', ', B[2]);
  // => B: 1, 2, 3

  B[1] := 42;

  writeln('B: ', B[0], ', ', B[1], ', ', B[2]);
  // => B: 1, 42, 3

  writeln('A: ', A[0], ', ', A[1], ', ', A[2]);
  // => A: 1, 42, 3

  // KOPIE
  B := Copy(A, 0, length(B));

  B[0] := 2;
  B[1] := 5;
  B[2] := 7;

  writeln('B: ', B[0], ', ', B[1], ', ', B[2]);
  // => B: 2, 5, 7

  writeln('A: ', A[0], ', ', A[1], ', ', A[2]);
  // => A: 1, 42, 3
end.

Ist das Prinzip jetzt klar?

[Tenobaal]

Okay, ich hab verstanden was du meinst. Es gab aber eine Besonderheit bei mir:
Der SetLength(...) Befehlt sorgt scheinbar dafür, dass neuer Speicher reserviert wird. Deshalb gabs bei mir arge Probleme.
Dazu folgendes Beispiel:

Delphi-Quellcode:

type TCoord_XY = record
  x,y:Double;
end;

type TPoints = Array of Array of TCoord_XY;
     PPoints = ^TPoints;

//...

procedure TForm1.FormCreate(Sender: TObject);
var PointsRotor: TPoints;
    Ptr3:TPoints;
begin
SetLength(PointsRotor, 1,1); //Setze Größe des Arrays direkt
PointsRotor[0,0].x:=1; //Schreibe was in das Array...

//...

//Variante 3
Ptr3:=PointsRotor;
SetLength(Ptr3,4,1);// Ptr3 bekommt neuen Speicher zugewiesen?!?
Ptr3[0,0].x:=2; //keine Auswirkung auf PointsRotor... PointsRotor[0,0] ist immernoch 1


//Variante 4
SetLength(Ptr3,4,1);
Ptr3:=PointsRotor;
Ptr3[0,0].x:=3; //Pointsrotor wird verändert
end;

end.

[sx2008]

Wieso verwendest du keine Klassen im Sinne der objekt-orientierten Programmierung?
In deinem Beitrag #1 redest du von Motoren und dessen Geometrie.
Warum gibt es dann keine Klasse TMotor oder T3DShape?

Diese Art zu denken man bräuchte einen Zeiger auf ein Array auf ein Array mit Records von x,y-Koordinaten nennt man primitive Obsession.
Code und Datenstruktur sind nicht miteinander verbunden sondern getrennt.
Das führt zu einer Vielzahl von Fehlern, da die Datenstrukturen ungeschützt sind.
In der OOP werden Daten und Code in Klassen verheiratet ("Kapselung") wobei der Code den Zugriff aus die Daten regelt.

Hier mal etwas Lesestoff zu OOP:
http://openbook.galileocomputing.de/oop/

[Bjoerk]

Zitat von Tenobaal:

Delphi-Quellcode:

type TCoord_XY = record
  x,y:Double;
end;

type TPoints = Array of Array of TCoord_XY;
     PPoints = ^TPoints;

procedure TForm1.FormCreate(Sender: TObject);
var PointsRotor: TPoints;
    Ptr3:TPoints;
begin
SetLength(PointsRotor, 1,1); //Setze Größe des Arrays direkt
PointsRotor[0,0].x:=1; //Schreibe was in das Array...

//Variante 3
Ptr3:=PointsRotor;
SetLength(Ptr3,4,1);// Ptr3 bekommt neuen Speicher zugewiesen?!?
Ptr3[0,0].x:=2; //keine Auswirkung auf PointsRotor... PointsRotor[0,0] ist immernoch 1


//Variante 4
SetLength(Ptr3,4,1);
Ptr3:=PointsRotor;
Ptr3[0,0].x:=3; //Pointsrotor wird verändert
end;

end.

Der Unterschied kommt deshalb zustande, weil Delphi bei jedem Aufruf von SetLength das Array kopiert.