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?

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

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

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

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

Du meinst wohl eher P^[i] , wobei Delphi solche Zeiger automatisch dereferenziert, wenn man mit einen Index darauf zugreift, deswegen auch einfach nur P[i] .

Zitat:

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 )

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 (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 von DeddyH:

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 von Neutral General:

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;