Freepascal->Delphi: Pointer als Array?

[Codehunter]

Hallo!

Ich habe das nächste seltsame Konstrukt aus Freepascal, das ich nicht so recht nach Delphi übersetzen kann:

Delphi-Quellcode:

type
  TPhysicalCharWidth = Byte;
  TPhysicalCharWidths = Array of TPhysicalCharWidth;
  PPhysicalCharWidth = ^TPhysicalCharWidth;

var
  I: Integer;
  P: PPhysicalCharWidth;
  T: TPhysicalCharWidths;

begin
  SetLength(T, Irgendwas);
  P:= @T[0];
  for I:= 0 to IrgendwasAnderes do begin
    P[I]:= 1; // <-- Compilerfehler "Array-Typ erforderlich"
  end;
end;

Da hab ich also im Ursprung ein Array of Byte und einen Zeiger auf das erste Element. Dann wird der Zeiger selbst als Array verwendet. Mal unabhängig davon, dass es der Delphi-Compiler nicht schluckt: Woher weiß der FP-Compiler, welche Größe ein Element im Array hat wenn man es über einen Pointer indiziert? :shock:

Aber die eigentliche Frage ist, wie man das geschickterweise übersetzen kann. Normalerweise würde ich das direkt mit dem Array machen. Aber im großen Gemenge reicht das über diverse Procedures und Klassen hinweg. Ich hab schon überlegt, den Zeiger wieder auf eine Procedure-lokale Variable vom Typ TPhysicalCharWidths umzulegen. Wäre das der richtige Ansatz?

Grüße
Cody

[Bummi]

P[i]^= oder T[i]=

[Codehunter]

Zitat:

Zitat von Bummi (Beitrag 1185337)

P[i]^= oder T[i]=

P[i]^= geht nicht, genau das selbe Problem (Array-Typ erforderlich) und T[i]= hab ich in dem Moment nicht, da der Procedure nur der Pointer übergeben wird.

Ich sollte dazu sagen, dass obiger Code wieder stark vereinfacht war. Mir geht es bei den Fragen hauptsächlich um das Funktionsprinzip, nicht darum die konkrete Routine umzubauen. Man will ja schließlich was dabei lernen :stupid:

Das einzige was mir einfiele wäre ein @T:= P und nachfolgend dann T[I]. Der Compiler täts ja schlucken aber obs funktioniert? Schließlich wüßte Delphi in dem Moment nicht, wie lang das Array ist. Oder ist das auch nullterminiert wie Strings? Kann ich mir nicht vorstellen.

[DeddyH]

Für P[i]^ müsste das aber ein Pointertyp auf das Array und nicht das Element sein, oder?

[Neutral General]

Es muss P^[i] heißen. Du willst ja das Array und nicht das i-te Element des Array dereferenzieren.

[himitsu]

Zitat:

Zitat von Bummi (Beitrag 1185337)

P[i]^= oder T[i]=

Du meinst wohl eher

Delphi-Quellcode:

P^[i]

, wobei Delphi solche Zeiger automatisch dereferenziert, wenn man mit einen Index darauf zugreift, deswegen auch einfach nur

Delphi-Quellcode:

P[i]

.

Zitat:

Delphi-Quellcode:

P:= @T[0];

Aber das ist natürlich falsch.
Entweder du willst den Pointer auf "dieses" Array und nicht auf einen Wert dieses Arrays. (wobei ich sowas nicht empfehlen würde, denn ein Array ist intern eh schon ein Zeiger ... wozu dann nochein zeiger :roll:)

Oder du machst P zu einem Zeiger auf einen statischen array of Byte, welchem du den Zeiger auf das erste Feld gibst (so wie jetzt schon gemacht).
Ein Zeiger auf dein "Byte", besitzt standardmäßig keine Pointerarithmetik, womit man dort nicht rechnen und somit auch keinen Index nutzen kann.
Dafür braucht man aber Pointerarithmetik, so wie es z.B. beim PChar vorhanden ist, wo man

Delphi-Quellcode:

(P + 3)^ = P[3]

verwenden kann.

Und woher FP das weiß ... dort wird diesem Typ eben die Pointerarithmetik zugewiesen.
Nja, die RTTI weiß die Größe auch, womit man das notfalls auch selbst berechnen könnte.

[Codehunter]

Zitat:

Zitat von DeddyH (Beitrag 1185341)

Für P[i]^ müsste das aber ein Pointertyp auf das Array und nicht das Element sein, oder?

Genau so sehe ich das auch. Was ich noch in petto hätte wäre die Anzahl der Elemente im Array, die wird der Procedure auch übergeben und wäre hier der Zielwert für die FOR-Schleife. Nur nochmal: Ich habe lediglich den Zeiger auf das erste Element im Array, welcher dereferenziert wieder ein Byte-Typ wäre und eben kein Array. Deshalb kann auch P^[I] eigentlich nicht funktionieren und bringt die selbe Compilermeldung "Array-Typ erforderlich".

Von der Sache her würde ich es so machen:

Delphi-Quellcode:

var
  T2: TPhysicalCharWidths;

begin
  SetLength(T2, AnzahlDerElemente);
  @T2[0]:= P;
end;

Aber so richtig schlüssig erscheint mir das auch nicht. So weiß zwar der Memory-Manager, wie viele Elemente T2 haben soll. Doch dann wird T2 auf eine andere Adresse umgebogen, was eigentlich zu einem Memleak führen müsste.

[Neutral General]

Hallo,

Also ich habe es jetzt mal getestet. himitsu hatte natürlich Recht und es muss P := @T; heißen und nicht P := @T[0];

Bei mir compiliert das hier aber ohne Probleme.
(Der Code kommt von FP und soll in Delphi laufen oder hab ich da was falsch verstanden?)

Delphi-Quellcode:

var t: TTestArray;
    p: PTestArray;
begin
  SetLength(t, 10);
  p := @t;
  // p := @t[0]; compiliert auch, aber funktioniert nicht
  p^[0] := 'A';
  Caption := p^[0];
end;

[Codehunter]

Zitat:

Zitat von Neutral General (Beitrag 1185358)

Der Code kommt von FP und soll in Delphi laufen oder hab ich da was falsch verstanden?

Genau. So stehts ja auch im Thread-Titel ;-)

Davon abgesehen funktioniert dein Ansatz in sich selbst vielleicht. Aber Du hast einen Zeiger auf das Array verwendet, ich habe aber nur einen Zeiger auf ein Array-Element. Darum funktioniert ein P^[I] bei mir nicht.

Wobei ich ja noch in den Raum stellen muss, dass ich mit D7 Pro arbeite, evtl. ist das in neueren Delphis anders?

[Bummi]

Sorry, für meinen Lapsus mit ^.
Habe ich richtig vertstanden dass Du einen Zeiger auf das erste Element bekommst?
Dann sollte folgendes gehen

Delphi-Quellcode:

type
  TPhysicalCharWidth = Byte;
  TPhysicalCharWidths = Array of TPhysicalCharWidth;
  PPhysicalCharWidth = ^TPhysicalCharWidth;



procedure Proz(p:Pointer;len:Integer);
var

 i:Integer;
begin
   for I := 0 to len - 1 do Showmessage(IntToStr(TPhysicalCharWidths(p)[i]))

end;

procedure TForm3.Button1Click(Sender: TObject);
var
  I: Integer;
  P: PPhysicalCharWidth;
  T: TPhysicalCharWidths;

begin
   SetLength(t,10);
   for i := Low(t) to High(t) do t[i] := i + 17;
   Proz(@T[0],Length(t));
end;

[Codehunter]

Zitat:

Zitat von Bummi (Beitrag 1185370)

Habe ich richtig vertstanden dass Du einen Zeiger auf das erste Element bekommst?

Öhm, ja :)

Zitat:

Zitat von Bummi (Beitrag 1185370)

Dann sollte folgendes gehen

Delphi-Quellcode:

type
  TPhysicalCharWidth = Byte;
  TPhysicalCharWidths = Array of TPhysicalCharWidth;
  PPhysicalCharWidth = ^TPhysicalCharWidth;



procedure Proz(p:Pointer;len:Integer);
var

 i:Integer;
begin
   for I := 0 to len - 1 do Showmessage(IntToStr(TPhysicalCharWidths(p)[i]))

end;

procedure TForm3.Button1Click(Sender: TObject);
var
  I: Integer;
  P: PPhysicalCharWidth;
  T: TPhysicalCharWidths;

begin
   SetLength(t,10);
   for i := Low(t) to High(t) do t[i] := i + 17;
   Proz(@T[0],Length(t));
end;

Und wo wird da jetzt der Zeiger auf das erste Element verwendet? Du erstellst doch nur ein neues leeres Array und holst dir nicht das bestehende mit dem Zeiger...:?:

Hach, ist wieder schwöööör zu erklären. P ist ein Zeiger auf das erste Element. Den generiere ich nicht selbst sondern der kommt von außen in die Prozedur. Gucks du hier in Zeile 810..854, Fehler in Zeile 819.

[Codehunter]

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
type
   TPhysicalCharWidth = Byte;
   TPhysicalCharWidths = Array of TPhysicalCharWidth;
   PPhysicalCharWidth = ^TPhysicalCharWidth;
var
  T1, T2: TPhysicalCharWidths;
  P: PPhysicalCharWidth;
  I, Len: Integer;
begin
  Len:= 10;
  SetLength(T1, I);
  for I:= Low(T1) to High(T1) do begin
    T1[I]:= I + 100;
  end;
  P:= @T1[0];

  SetLength(T2, Len);
  T2[0]:= P^;
  for I:= 1 to Len - 1 do begin
    Integer(P):= Integer(P) + SizeOf(TPhysicalCharWidth);
    T2[I]:= P^;
  end;

end;

Ich verschiebe den Zeiger in einer Schleife jeweils um eine Position anhand der Größe eines Elements. Das funktioniert sogar, nur habe ich dann eine Kopie des ursprünglichen Arrays und nicht das Original. Im Ergebnis kann ich dann zwar die Werte lesen aber nicht in das ursprüngliche Array streiben :(

[Bummi]

Delphi-Quellcode:

type
  TPhysicalCharWidth = Byte;
  TPhysicalCharWidths = Array of TPhysicalCharWidth;
  PPhysicalCharWidth = ^TPhysicalCharWidth;



procedure Proz(p:Pointer;len:Integer);
var

 i:Integer;
begin
   for I := 0 to len - 1 do
        TPhysicalCharWidths(p)[i] := TPhysicalCharWidths(p)[i] - 17;
end;

procedure TForm3.Button1Click(Sender: TObject);
var
  I: Integer;
  P: PPhysicalCharWidth;
  T: TPhysicalCharWidths;

begin
   SetLength(t,10);
   for i := Low(t) to High(t) do
      begin
      t[i] := i + 17;
      Memo1.Lines.Add(IntToStr(t[i]));
      end;
   Proz(@T[0],Length(t));

   Memo1.Lines.Add('Nach Proz');

   for i := Low(t) to High(t) do
      begin
      Memo1.Lines.Add(IntToStr(t[i]));
      end;


end;

irgendwo ist jetzt ein Konten drin ... ich lege keine Kopie an und kann zurückschreiben, wo ist mein Denkfehler?

[Codehunter]

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
type
   TPhysicalCharWidth = Byte;
   TPhysicalCharWidths = Array of TPhysicalCharWidth;
   PPhysicalCharWidth = ^TPhysicalCharWidth;
var
  T1: TPhysicalCharWidths;
  P: PPhysicalCharWidth;
  I, Len: Integer;
begin
  // Anzahl der Elemente festlegen
  Len:= 10;

  // Ursprungs-Array erzeugen und mit Daten belegen
  SetLength(T1, I);
  for I:= Low(T1) to High(T1) do begin
    T1[I]:= I + 100;
  end;
  P:= @T1[0];

  // Ab hier wird nur noch mit dem Zeiger gearbeitet
  for I:= 0 to Len - 1 do begin
    Integer(P):= Integer(P) + SizeOf(TPhysicalCharWidth);
    P^:= P^ + 100;
  end;

  Caption:= IntToStr(T1[5]);  // --> Ergibt 205
end;

Gelesen und geschrieben ins ursprüngliche Array of Byte. Jetzt muss ich nur noch die Adresse des ursprünglichen Zeigers P zwischenspeichern und am Ende wiederherstellen.

Meine Güte, das ist ja wirklich eine wilde Zeigerschubserei. Zwischendurch hat sich da sogar mein Virenschutz gemeldet und darin einen Trojaner erkannt.

@Bummi: Jetzt hab ichs auch gesehen in deinem Code. Hast natürlich recht, ich habe die Dereferenzierung in "Proz" übersehen.

Das Konstrukt ist im Originalquelltext an sich ziemlich :firejump: aber was will man machen. Es soll ja "nur" ein Backport werden und kein komplettes Rewite.