Konstante Übergabevariablen bei Prozeduren/Funktionen

[mleyen]

Bei strings kann es ohne const sein, dass der Compiler diesen komplett kopiert und der somit 2 mal im RAM liegt.
Es gab da mal einige ASM /- Performancevergleiche die stark abweichten.
Ich denk mal das es bei Int genauso ist. Ich schreib einfach überall const dran wo es geht. (nur lesende Parameter)

[Cyberstorm]

Zitat von mleyen:

Bei strings kann es ohne const sein, dass der Compiler diesen komplett kopiert und der somit 2 mal im RAM liegt.
Es gab da mal einige ASM /- Performancevergleiche die stark abweichten.
Ich denk mal das es bei Int genauso ist. Ich schreib einfach überall const dran wo es geht. (nur lesende Parameter)

Genau an soetwas hatte ich gedacht.

Kann das jemand bestätigen, widerlegen?

[himitsu]

Ein String, dynamische Arrays und Interfaces haben eine Referenzzählung, da werden nur Referenzen hoch-/runtergezählt.
Da kann sich ein CONST eventuell lohnen, aber im allgemeinen ist soein kleines IF+INC+DEC recht flott, as daß man es oftmals überhaupt merkt.
Deßhalb laß ich dieses CONST auch bei Strings und dyn. Arrays oftmals weg, da so die Funktionsdeklaration (für mich) dann übersichtlicher wird, da kürzer und man nicht durch dieses hervorgehobene CONST abgelenkt wird.

Aber beim ShortString, Records und statischen Arrays sieht das schnell mal ganz anders aus.

Ein Integer ist hier quasi ein Sonderfall, denn der ist kleingenug, um in ein CPU-Register zu passen, darum macht dort CONST oder nicht keinen Unterschied.
Nur bei VAR wird dort ja eine Referenz übergeben und nicht der Wert.
Auch ein Int64 wird eventuell, mit der Standardaufrufkonvention, hier genauso behandelt, da dort der Wert in zwei Register paßt, also wenn dieses der erste Parameter ist (EAX+EDX ist ja eine allgemein übliche Kombination)


Also gehen wir mal auf größere Typen los, wie z.B. ein array[0..10000000] :
{nix} - eine Kopie des Arrays wird angelegt (das Kopieren und eventuell späteres Freigeben kann schonmal etwas dauern)
CONST - eine Referenz (Zeiger) auf das Array wird übergeben und, für den Compiler, als schreibgeschützt markiert
VAR - eine Referenz auf das Array wird übergeben

[Medium]

Und wie immer der Hinweis: Wenn man ein Objekt als Konstant übergibt, so verhindert der Compiler zwar das Ändern der Referenz, die Member können aber problemlos übernagelt werden. Objekte werden übrigens immer als Referenz übergeben, so dass dort das const nicht mehr macht als eben die Referenz zu schützen. Ich bin nur grad unsicher, was bei einer Änderung der Referenz ohne var passiert. Dürfte nur lokale Auswirkungen haben, zumindest was die Referenz an sich angeht. Nicht die Member.

[himitsu]

Objekte sind intern "Zeiger", also Pointer und Pointer sind wie Integer.

PS: bei dynamischen Arrays muß man auch extrem aufpassen, denn diese verfügen zwar über eine Referenzzählung, aber beim Schreibzugriff auf deren Inhalt kann shconmal was schief gehn, da Delphi hier seit Urzeiten eine "Optimierung" verbaut hat.

Delphi-Quellcode:

procedure P1(var X: TBytes);
begin
  X[2] := 81;
end;

procedure P2(X: TBytes);
begin
  X[2] := 82;
end;

procedure P3(const X: TBytes);
begin
  X[2] := 83;  // in D2010 löst es komischer Weise keinen Compilerfehler aus o.O
end;

procedure TForm3.FormCreate(Sender: TObject);
var A, B: TBytes;
begin
  SetLength(A, 5);
  A[0] := 0;
  A[1] := 1;
  A[2] := 2;
  A[3] := 3;
  A[4] := 4;
  ShowMessage('0: ' + IntToStr(A[2]) + ' und sollte auch noch 2 bleiben');
  P1(A);
  ShowMessage('1: ' + IntToStr(A[2]) + ' und sollte nun auch 81 sein');
  P2(A);
  ShowMessage('2: ' + IntToStr(A[2]) + ' und sollte eigentlich 81 bleiben');
  P3(A);
  ShowMessage('3: ' + IntToStr(A[2]) + ' und sollte ebenfalls 81 bleiben');
  B := A;
  B[2] := 88;
  ShowMessage('B: ' + IntToStr(A[2]) + ' und sollte immernoch 81 sein');
end;

[Cyberstorm]

Ich danke Euch für die ausführlichen Ausführungen!

Ich denke, es ist nicht verkehrt sich anzugewöhnen const zu definieren wenn der Wert innerhalb der Funktion/Prozedur nicht verändert wird, auch wenn es sich nur bei großen Datenmengen bemerkbar macht.



Viele Grüße

[BUG]

Zitat von mleyen:

Ich denk mal das es bei Int genauso ist.

Bei Integer wäre es idiotisch der Funktion bei einem const-Parameter einen Zeiger statt des Wertes zu übergeben, da der Zeiger in Delphi immer größergleich der Integergröße ist und man in der Funktion eine Dereferenzierung zusätzlich machen müsste (bei jedem Zugriff oder einmalig beim Ablegen in einer lokalen Variable).

Bei größeren Nichtzeigertypen (= Records / statischen Array) könnte sich das aber lohnen.