Angenommen ich habe:

type
PBla=^TBla;

und dann eine Prozedur:

procedure Bla(Bla: TBla);

oder

procedure Bla(Bla: PBla);

Gibt es da einen Unterschied, ist irgendwas schneller/besser/sicherer/schöner/konventionskonformer/leichter?

Man sollte Zeiger falls möglich vermeiden.
Es gibt noch folgende Varianten:

markieren

Delphi-Quellcode:

// als VAR-Parameter (wird intern als Zeiger übergeben)
procedure Bla(var Bla: TBla);

// als const Parameter (wird intern auch als Zeiger übergeben)
procedure Bla(const Bla: TBla);

Und wieso sollte man Pointer vermeiden? Ich dachte halt, die sind schneller, wenn nicht gleich das ganze Objekt übergeben wird.

ich frag mich immer wieder, wieso hier noch soviel "altes" pascal geschrieben wird. man braucht heute eigentlich nicht mehr TBla und PBla als Zeiger auf TBla zu erstellen, denn wenn TBla eine Klasse ist dann sind Instanzen davon intern automatisch Zeiger.

Früher hat man Klassen mit dem Schlüsselwort object statt class erzeugt. Damals waren Instanzen dann keine Zeiger und deswegen hat man immer noch PIrgendwas = ^TIrgendwas erzeugt, damit man nicht immer massenweise Daten durch den speicher schiebt.

aber wie gesagt: Das ist heute nicht mehr notwendig. Vergesst es.

Vermutlich sind einfach zuviele alte Tutorials im Umlauf. Oder wo habt ihr diese altbackenen Verfahren her?

object = Record mit Methoden
class = Pointer auf Record mit Methoden
^class = PPointer...

Bei einem Var- oder einem Const-Parameter werden auch nur Zeiger übergeben (bei Const bin ich mir grad nicht so sicher, wie das funktioniert, aber bei var ganz sicher)

Näheres dazu unter Parameter

@bttb930: Reg dich ab, ich kann es nicht besser wissen.

noch ein kleines Demo:

zusammenfalten · markieren

Delphi-Quellcode:

type
  TBla = class
  private
    FFeld: string;
  public
    property Feld: string read FFeld write FFeld;
  end;

procedure Change(const aBla: TBla);
begin
  aBla.Feld := 'Hallo';
end;

...

var
  bla: TBla;
begin
  bla := TBla.Create;
  bla.Feld := 'Blub';
  Change(bla);
  ShowMessage(bla.Feld);
  bla.Free;
end;

Ausgegeben wird Hallo und nicht Blub. Denn übergeben wird an Change nur der Zeiger der auf den Inhalt von bla zeigt. Der wird als const übergeben. Die Zeile aBla.Feld := 'Hallo'; ändert aber nicht den Wert von aBla (also die Adresse auf die der Zeiger zeigt), sondern nur den Inhalt von aBla.Feld.

Würde nicht ein Zeiger übergeben werden, sondern der komplette Inhalt von bla, dann wäre in Change das Ändern von Feld nicht möglich, da aBla als const deklariert ist.

Zitat von 3_of_8:

Und wieso sollte man Pointer vermeiden? Ich dachte halt, die sind schneller, wenn nicht gleich das ganze Objekt übergeben wird.

Natürlich ist es schneller, einen Zeiger auf einen Record zu übergeben, als den gesamten Record zu kopieren.
Es ist aber besser var- oder const- Parameter zu benützen und es dem Compiler zu überlassen
intern Zeiger zu verwenden. So kann man als Programmierer einfach weniger Fehler produzieren.
Dies bezieht sich auf Records; du hast aber (erst jetzt) von Objekten gesprochen.

Alle Datentypen, die von TObject abgeleitet sind, werden intern schon als Zeiger verwaltet.
Es gibt also keinen Grund, einen Zeiger auf einen Zeiger einzuführen.
Das lässt sich ganz leicht nachprüfen:

markieren

Delphi-Quellcode:

procedure Bla(param: TBla);
begin
   ShowMessageFmt('Parameter <param> braucht %d Bytes', [sizeof(param)]);
end;

Zitat von 3_of_8:

@bttb930: Reg dich ab, ich kann es nicht besser wissen.

sorry wenn das falsch rüber kam, aber ich hab mich nicht aufgeregt, schon gar nicht speziell über dich. Ich wunder mich nur wieso diese altbackene methode (die unter Turbo Pascal 5.0 eingeführt wurde und damals auch nicht anders ging) noch immer so verbreitet ist.