Die größer Zahl nehmen ?

[himitsu]

also seit 'ner Weile gibt's das wieder (weiß nicht genau, seit D2006 auf jeden Fall)

[Matze]

Zitat:

Zitat von Cyf

Warum ist hier eigentlich das const sinnvoll?

Das ist eine gute Frage. Wie du siehst habe ich es in "meiner" Funktion ebenfalls verwendet.
Es gab hier mal ein Thema (vielleicht gibt es das auch noch), im dem der Sinn des Ganzen beschrieben war. Seitdem habe ich mir gemerkt, wenn die Parameter-Werte in der Funktion nicht verändert werden, ein "const" davor zu setzen.

Mich würde es jedoch auch interessieren, wieso genau ich das davor setze. :mrgreen: Vielleicht bin ich zu gutgläubig.

Grüße, Matze

[DeddyH]

Bevor ich mir hier den Wolf tippe:

Zitat:

Zitat von Delphi 7-Hilfe

Wert- und Variablenparameter
Die meisten Parameter sind Wert- (Standard) oder Variablenparameter (var). Wertparameter werden als Wert übergeben, Variablenparameter als Referenz. Der Unterschied wird anhand der folgenden beiden Funktionen deutlich:

Delphi-Quellcode:

function DoubleByValue(X: Integer): Integer;     // X ist ein Wertparameter
begin
  X := X * 2;
  Result := X;
end;
function DoubleByRef(var X: Integer): Integer;***// X ist ein Variablenparameter
begin
  X := X * 2;
  Result := X;
end;

Diese Funktionen liefern das gleiche Ergebnis. Nur die zweite Funktion (DoubleByRef) kann jedoch den Wert der an sie übergebenen Variablen ändern. Die Funktionen können beispielsweise folgendermaßen aufgerufen werden:

Delphi-Quellcode:

var
  I, J, V, W: Integer;
begin
  I := 4;
  V := 4;
  J := DoubleByValue(I);   // J = 8, I = 4
  W := DoubleByRef(V);     // W = 8, V = 8
end;

Nachdem diese Anweisungen ausgeführt wurden, enthält die an DoubleByValue übergebene Variable I immer noch den ursprünglichen Wert. Die an DoubleByRef übergebene Variable V enthält dagegen einen neuen Wert.

Ein Wertparameter verhält sich wie eine lokale Variable, die durch den im Aufruf der Funktion oder Prozedur übergebenen Wert initialisiert wird. Wenn Sie eine Variable als Wertparameter übergeben, erstellt die Prozedur oder Funktion eine Kopie dieser Variablen. Änderungen des Wertes dieser Variablen wirken sich nicht auf die ursprüngliche Variable aus.

Sie werden verworfen, sobald die Steuerung wieder an den Aufrufer zurückgegeben wird. Ein Variablenparameter ist dagegen mit einem Zeiger vergleichbar. Änderungen des Parameters im Rumpf einer Prozedur oder Funktion bleiben deshalb erhalten, wenn die Programmausführung wieder dem Aufrufer übergeben wird und der Parametername nicht mehr im Gültigkeitsbereich liegt.

Auch wenn dieselbe Variable in mehreren var-Parametern übergeben wird, werden keine Kopien erstellt. Dieses Merkmal wird im folgenden Beispiel illustriert:

Delphi-Quellcode:

procedure AddOne(var X, Y: Integer);
begin
  X := X + 1;
  Y := Y + 1;
end;
var I: Integer;
begin
  I := 1;
  AddOne(I, I);
end;

Nachdem dieser Code ausgeführt wurde, enthält die Variable I den Wert 3.

Enthält die Deklaration einer Routine einen var-Parameter, müssen Sie im Aufruf der Routine einen Ausdruck übergeben, dem ein Wert zugewiesen werden kann, also eine Variable, eine typisierte Konstante (im Status {$J+}), einen dereferenzierten Zeiger, ein Feld oder eine indizierte Variable. Im Beispiel weiter oben würde DoubleByRef(7) einen Fehler generieren, während der Aufruf DoubleByValue(7) zulässig wäre.

In var-Parametern (beispielsweise DoubleByRef(MyArray[I])) übergebene Indizes und dereferenzierte Zeiger werden vor der Ausführung der Routine einmal ausgewertet.


Konstantenparameter
Ein Konstantenparameter (const) entspricht einer lokalen bzw. schreibgeschützten Variablen. Konstantenparameter entsprechen weitgehend Wertparametern. Sie können ihnen jedoch im Rumpf einer Prozedur oder Funktion keinen Wert zuweisen und sie nicht als var
-Parameter an eine andere Routine übergeben. Übergeben Sie eine Objektreferenz als Konstantenparameter, können Sie weiterhin auf die Objekteigenschaften zugreifen und diese ändern.

Die Verwendung von const ermöglicht dem Compiler die Optimierung des Codes für strukturierte und String-Parameter. Gleichzeitig wird die versehentliche Übergabe eines Parameters als Referenz an eine andere Routine verhindert.

Das folgende Beispiel ist der Header der Funktion CompareStr in der Unit SysUtils:

Delphi-Quellcode:

function CompareStr(const S1, S2: string): Integer;

Da S1 und S2 im Rumpf von CompareStr nicht geändert werden, können sie als Konstantenparameter deklariert werden.

[edit]

Zitat:

Bevor ich mir hier den Wolf tippe:

Sorry, Chäffe, das Wortspiel ist mir selbst erst später aufgefallen :lol: [/edit]

[himitsu]

solange man bei einem Integer/LongInt/SmallInt/ShortInt/Cardinal/LongWord/Word/Byte/Boolean mit Var/Out arbeitet, wird eine Refferenz übergeben ... wenn man Const oder nichts übergibt, dann wird (zumindestens bei der Konvention PASCAL ... bei den anderen weiß ich es jetzt nicht) nur der Inhalt koppiert da dieses in der Verarbeitung schneller ist ... muß dann ja nur noch aus dem Variablenspeicher gelesen und nicht erst die Referenz aufgelöst werden.

Vorallem bei größeren Typen wird bei Const/Var/Out die Referenz übergeben und ohne eine Angabe eine Kopie des Inhalts angelegt und damit geareitet.
für IN bin ich mir grad nicht ganz sicher.

Sozusagen: in Delphi gibt es in der Standardaufrufkonvention und bei vielen Typen kleiner-gleich Integer eigentlich keinen Unterschied zwischen Const oder Nichts ... aber es kann auch nicht schaden, wenn man es macht ... wenn man es immer macht, vergißt man es nicht bei Typen, wo es besser wär :stupid:

[globetrotter77]

Wenn ich es richtig verstanden habe, meckert der Compiler also, wenn ich aus proc1(Const a: xy)
eine proc2(var b:yz) mit meinem konstanten Parameter aufrufe.

Das war früher anders. Da konnte man sowas machen und in der Procedure proc1 mit dem veränderten Parameter weitermachen, aber eben nur intern! An die ursprüngliche Aufrufstelle wurde dann keine Veränderung zurückgegeben.

So gesehen, macht das durchaus Sinn!

[himitsu]

wie, das ginge früher mal?

weder in D7 noch Neuer geht's

Delphi-Quellcode:

procedure Test2(var x: Integer);
begin
  x := 123;
end;

procedure Test1(const x: Integer);
begin
  Test2(x);  // [Fehler] Unit1.pas(32): Konstantenobjekt kann
end;         // nicht als Var-Parameter weitergegeben werden

procedure TForm1.FormCreate(Sender: TObject);
begin
  Test1(Tag);
end;

man kann es sich so vorstellen (von der Verwendung her):
mit Const ist der Parameter wie eine Konstante
ohne Const ist es wie eine lokale Vaiable, welche beim Prozedurstart vorbelegt wurde

[globetrotter77]

Zitat:

Zitat von himitsu

wie, das ginge früher mal?

war wohl etwas flapsig formuliert ... ich meinte eine procedure, in der kein const angegeben ist.
Außerdem meine ich mit früher sowas wie Turbo Pascal, da kommt das ja alles her. und das kannte auch keine const-Angabe bei den Parametern.

Zitat:

man kann es soe so vorstellen (von der Verwendung her)
mit Const ist der Parameter wie eine Konstante
ohne Const ist es wie eine lokale Vaiable, welche beim Prozedurstart vorbelegt wurde

das dürfte die richtige Formulierung sein!

[globetrotter77]

und das geht auch heute noch! gerade ausprobiert!

wenn dagegen const dabei steht, gibt es ne Fehlermeldung vom Compiler:
E2197 Konstantenobjekt kann nicht als Var-Parameter weitergegeben werden

[himitsu]

ja klar, ohne CONST ist es ja keine Konstante mehr und darf verändert werden.