(const Param:Integer)oder(Param:Integer)-Unterschied?

[sniper_w]

Ich würde gerne mal wissen ,wo genau liegt die Unterschied zwischen zwei Deklarationen:

Delphi-Quellcode:

// Fall 1
function MyFunc(const Param:Integer):Boolean;

und

Delphi-Quellcode:

// Fall 2
function MyFunc(Param:Integer):Boolean;

Soviel ich weiss, im Fall 1 kann man die "Param" Variable in der Funktion nicht ändern, sondern nur deren Wert benutzen.
Im Fall 2 wird eine Lokale Kopie von Param angelegt, und mir der kann man dann alles machen, was man sonst mit einer Variavle machen kann, hat aber keine Auswirkungen nach aussen.

Gibt es noch welche Unterschiede? Und wo ist der Sinn der Sache, const oder nicht const ?

[Olli]

Übergabe:
Fall 1: Referenz
Fall 2: Wert

[SirThornberry]

function MyFunc(const Param:Integer):Boolean; ist das gleiche wie
function MyFunc(var Param:Integer):Boolean; mit dem großen Unterschied das bei "const" der Wert nicht geändert werden darf/kann.

[Olli]

out hast du dann vergessen ... das gehört auch in diese Reihe. In C hingegen ist OUT nur ein leeres Makro.

[SirThornberry]

genau, out gibt es auch noch.
Einen Nachtrag noch zu dem Const.
Wenn du folgendes versuchst

Delphi-Quellcode:

function MyFunc(const Param:Integer):Boolean;
begin
  Param := 9;
end;

meckert der Compiler eben weil es ein Constanter Wert ist.

wenn du aber das ganze so machst

Delphi-Quellcode:

function MyFunc(const Param:Integer):Boolean;
begin
  PInteger(@Param)^ := 9;
end;

dann meckert kein Compiler und du siehst das der Übergabewert sich ändert.

wenn du also zweite variante wie folgt aufrufst

Delphi-Quellcode:

var test1: Integer;
begin
  test1 := SpinEdit1.Value;
  ShowThat(test1);
  showmessage(inttostr(test1));

und SpinEdit1.Value = 5 ist, dann
wirst du bei deinem ShowMessage dann sehen das test1 auf einmal 5 ist weil das const überlistet wurde. Und genau dafür ist Const eigentlich da, damit sowas nicht passiert.

[jbg]

Zitat von SirThornberry:

und SpinEdit1.Value = 5 ist, dann
wirst du bei deinem ShowMessage dann sehen das test1 auf einmal 5 ist

Da stimmt doch was nicht. Wenn ich beim SpinEdit eine 5 einstelle und dann nach deiner Theorie dann doch eine 5 sehe, obwohl nach deiner Theorie ein 9 da stehen muss, dann kann da doch was nicht stimmen

Das const hat bei Integer nur die Wirkung, dass der Compiler den Parameter nicht verändern lässt. Er wird aber immernoch mit ByValue übergeben. const hat hauptsächlich bei Strings eine besondere Bedeutung. Fehlt es dort nämlich, muss der Compiler einen try/finally Block aufbauen, der die Referenzzählung des Strings verwaltet. Ansonsten könnte man ja den String nach außen hin verändern (Seiteneffekt). Und genau hier ist das const eine Optimierung, die einiges an Geschwindigkeit aus so manchen Programmen herausholen kann.

Probiert mal folgenden Code einmal ohne "const" und dann mit aus. Da braucht man nicht mal einen Profiler um den Geschwindigkeitsunterschied feststellen zu können. Ein Breakpoint

Delphi-Quellcode:

procedure Stupid({const} S: string);
begin
  Length(S); // damit da nichts wegoptimiert wird
end;

procedure DoSomething;
var
  A: string;
  i: Integer;
begin
  A := 'Hallo';
  A := A + ' du da'; // damit A keinen Konstanten-Referenzzähler hat (=-1)
  for i := 0 to 50000000 do
    Stupid(A);
end;

initialization
  DoSomething; // hier Breakpoint setzen (F5), Programm staten (F9) und drüber steppen (F8)

end.

Vorausgesetzt ist natürlich immer, dass man die String-Parameter in der Funktion auch nicht ändert, also ein const überhaupt möglich ist.

[SirThornberry]

ich kenn den unterschied, ich wollte damit nur die wirkungsweise von const demonstrieren, nämlich das eine referenz übergeben wird und keine kopie, und das konnte man wunderbar demonstrieren in dem man das const "ignoriert" und den wert innerhalb der funktion ändert.

[sniper_w]

Zitat von SirThornberry:

function MyFunc(const Param:Integer):Boolean; ist das gleiche wie
function MyFunc(var Param:Integer):Boolean; mit dem großen Unterschied das bei "const" der Wert nicht geändert werden darf/kann.

Das Unterschied ist auch im Aufruf:
Fall 1:MyFunc(3);//<-OK Fall 2:MyFunc(3);//<-Fehler

[jbg]

Zitat von SirThornberry:

ich kenn den unterschied

Womöglich doch nicht, oder du beziehst dich auf einen anderen Datentyp als Integer.

Zitat:

ich wollte damit nur die wirkungsweise von const demonstrieren, nämlich das eine referenz übergeben wird und keine kopie

Das hängt vom Datentyp des Parameters ab. Bei Integern wird bei const trotzdem eine Kopie auf den Stack gelegt:

Code:

mov eax, [MyInteger] // Wert von MyInteger in eax (=1. Parameter bei register-Call)
call DoSomeWildThings

Bei einem CallByRef müsste der Code so aussehen:

Code:

mov eax, OFFSET MyInteger // Adresse von MyInteger in eax (=1. Parameter bei register-Call)
call DoSomeWildThings

Oder alternativ:

Code:

lea eax, MyInteger // Adresse von MyInteger in eax (=1. Parameter bei register-Call)
call DoSomeWildThings

Bei Arrays und Records stimmt deine Aussage. Eine Faustregel ist: Alles was sich in 4 Bytes reinquetschen lässt, wird bei const als Kopie auf den Stack übergeben. Alles andere geht als Zeiger auf den Stack.

Zitat:

und das konnte man wunderbar demonstrieren in dem man das const "ignoriert" und den wert innerhalb der funktion ändert.

Das funktioniert bei Integer aber nicht. Egal wierum man das Blatt wendet.

[SirThornberry]

Komich, als ich aber per Pointer zugriff in der Funktion den Integer der mit Const übergeben wurde geändert hab wurde auch der Original-Integer geändert. Wohlmöglich sehen bei dir die Assemblerbefehle nur anders aus weil in deinem Beispiel etwas optimiert wird. Wenn ich nicht über den Umweg von SpinEdit1.Value sondern den Value fest in den Source codiere dann klappt das auch nicht weil dann durch die optimierung der Wert direkt übergeben wird ohne die Variable.