Unterschied zwischen (var AFileStream: TFileStream) und (AFileStream: TFileStream)

[p80286]

Zitat von Sir Rufo:

Hier wird das doch erklärt?
http://docwiki.embarcadero.com/RADSt...meter_(Delphi)

Eben nicht, oder besser gesagt nur für die einfachen Typen wie Integer,Boolean usw. Da ist wohl seit TP 3 immer wieder abgeschrieben worden?

Delphi-Quellcode:

procedure Zeigwas(const wert:string ;Lb:Tlabel);
begin
  lb.caption:=wert;  
end;

so bekommt das Label einen neuen Wert, ist ja klar, wenn man sich vor Augen hält, daß hier die Adresse von einem Label übergeben wird und nicht das Label oder eine neue Instanz des Labels.
Ob das alles allerdings so ganz sauber und im Sinne des Erfinders ist

Gruß
K-H

[Sir Rufo]

Es gibt call by value, call by reference und const parameter.

Ein kleiner Test zeigt die Unterschiede

Delphi-Quellcode:

program dp_180328;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  System.SysUtils;

type
  TTest = class
  end;

procedure Output( const AContext : string; AInstance : TTest );
begin
  if Assigned( AInstance )
  then
    Writeln( AContext, ': ', Integer( AInstance ) )
  else
    Writeln( AContext, ': NIL' )

end;

procedure CallByValue( AInstance : TTest );
begin
  AInstance := TTest.Create;
  Output( 'CallByValue', AInstance );
end;

procedure CallByReference( var AInstance : TTest );
begin
  AInstance := TTest.Create;
  Output( 'CallByReference', AInstance );
end;

procedure Call( const AInstance : TTest );
begin
  // Auskommentiert, da es hier einen Compiler-Fehler gibt!
  // AInstance := TTest.Create;
  // Output( 'Call', AInstance );
end;

procedure Main;
var
  LTest : TTest;
begin
  LTest := TTest.Create;
  try
    Output( 'Main', LTest );
    CallByValue( LTest );
    Output( 'Main', LTest );
    CallByReference( LTest );
    Output( 'Main', LTest );
    Call( LTest );
    Output( 'Main', LTest );
  finally
    LTest.Free;
  end;
end;

begin
  try
    Main;
  except
    on E : Exception do
      Writeln( E.ClassName, ': ', E.Message );
  end;
  ReadLn;

end.

Die Ausführung ergibt dann

Code:

Main            : 31925952
CallByValue     : 31925968
Main            : 31925952
CallByReference: 31925984
Main            : 31925984
Main            : 31925984

[himitsu]

Mit dem CONST, VAR und OUT bestimmt man nur, ob der "Inhalt" der Variable verändert werden kann.
Bei einem Integer ist das der Zahlenwert, aber bei einem Objekt ist der nur der interne Instanz-Zeiger.

Ohne VAR kann man keine Andere Instanz eines Objektes zurückgeben, aber der "Inhalt" des Objektes ist davon nicht betroffen.

Prinzipiell wird der "Inhalt" aller Pointer-Objekte nicht beeinflusst.
Außer bei Strings (AnsiString, WideString und UnicodeString, ausgeschlossen den ShortStrings, welche ja wie Records reagieren), denn dort sorgt der Compiler für eine Prüfung und "verbietet" Schreibzugriffe, wenn der Parameter CONST ist und ansonsten sorgt der Compiler dort für die entsprechende Behandlung, indem der Inhalt automatisch "umkopiert" wird, bei einem Schreibzugriff.

[Sir Rufo]

Wenn man weiß was bei einer Instanz übergeben wird (nur eine Referenz, quasi eine Visitenkarte), dann versteht man auch die Delphi-Dokumentation.

Mit dem var wird die gleiche Visitenkarte (Referenz) übergeben. Bemale ich die, dann ist die bemalt.

Ohne dem var wird eine Kopie der Visitenkarte (Referenz) übergeben. Bemale ich die, dann ist eben diese Kopie bemalt und das Original bleibt unverändert.

Mit dem const wird die Visitenkarte (Referenz) als unbemalbares Objekt (Read-Only) übergeben und kann gar nicht bemalt werden.

[OlafSt]

Keiner hat die Frage wirklich verstanden, ergo hat sie auch keiner wirklich beantwortet. Ist übrigens eine Frage, die ich mir vor langer Zeit auch mal stellte und dann einfach beschloß "ist halt so":

Ich nehme einen TFileStream und öffne eine Datei.
Nun rufe ich eine Methode auf, und übergebe diesen Stream als Parameter.
In dieser Methode wird nun per Seek -Methode des TFileStreams an das Ende der Datei gesprungen.

Es ist echt schnurzpiepegal, ob ich den TFileStream als CONST , VAR oder auch normal übergebe, die Seek-Methode verschiebt den Dateizeiger ans Ende der Datei. Ergo verändere ich doch den TFileStream (wenigstens seinen Dateizeiger !), was doch dem CONST widerspricht.

Ich habe das irgendwann einfach so akzeptiert, das CONST nicht vollständig auf Objekte wirkt.

[DeddyH]

Du änderst nur Eigenschaften des Streams, aber nicht den Stream (also die übergebene Instanz) selbst. Das wäre aber möglich, wenn man ihn als Var-Parameter übergibt, und kann zu sehr hässlichen Nebenwirkungen führen, wenn man nicht weiß, was man da tut. Ein Negativbeispiel findet sich z.B. hier (unten unter "Vorsicht bei Zeigertypen!").

[Sir Rufo]

@OlafSt

Wenn ich dir meinen Schlüssel zu meiner Wohnung gebe, dann kannst du in die Wohnung rein und dort umräumen.
Tauscht du den Schlüssel nun aus und gibts mir diesen zurück, komme ich nicht mehr in meine Wohnung.
procedure Foo( var AKey : TWohnung ); Gebe ich dir eine Kopie meines Schlüssels, dann kannst du immer noch in die Wohnung rein und umräumen.
Da ich aber keinen Schlüssel von dir zurücknehme, kann ich trotzdem noch mit meinem Schlüssel in meine Wohnung (und sehe dann entweder Chaos oder endlich mal eine aufgeräumte Wohnung)
procedure Foo( AKey : TWohnung );

[OlafSt]

...oder eine leere wohnung

Ich persönlich habe das ganze ja schon länger verstanden (auch wenn ich der Ansicht bin, das CONST nun mal CONST ist, auch Eigenschaften sollten dann unveränderlich sein).

Ich hoffe, der TE bekam nun seine Antwort

[michele_tedesco]

Zitat von Sir Rufo:

@OlafSt

Wenn ich dir meinen Schlüssel zu meiner Wohnung gebe, dann kannst du in die Wohnung rein und dort umräumen.
Tauscht du den Schlüssel nun aus und gibts mir diesen zurück, komme ich nicht mehr in meine Wohnung.
procedure Foo( var AKey : TWohnung ); Gebe ich dir eine Kopie meines Schlüssels, dann kannst du immer noch in die Wohnung rein und umräumen.
Da ich aber keinen Schlüssel von dir zurücknehme, kann ich trotzdem noch mit meinem Schlüssel in meine Wohnung (und sehe dann entweder Chaos oder endlich mal eine aufgeräumte Wohnung)
procedure Foo( AKey : TWohnung );

In deinem Beispiel wird aber die Wohnung übergeben und dicht der Schlüssel

Wenn ich an der Kopie des Schlüssels etwas ändere (Eigenschaft: Farbe, oder Form), dann ist bei procedure Foo( AKey : TKey ); dann ist doch auch der Original-Schlüssel geändert, richtig?

Gibt es eine Möglichkeit (gibt es überhaupt Situationen) wo das Objekt vollkommen als Kopie übergeben wird??

Ist das Verhalten in .Net das selbe?

[bernau]

Zitat von OlafSt:

Keiner hat die Frage wirklich verstanden, ergo hat sie auch keiner wirklich beantwortet.

Süß

Sir Rufo hat es genau richtig beschrieben.