optionale Parameter mit object-type?

[bcvs]

Zitat von SearchBot:

Muss ich dann jetzt auch contructor und destructor einbauen, weil - es läuft grundlegend erstmal auch so, aber beim Zugriff auf die Variable "script" mit

Code:

if not assigned(script) then script:=TStringList.create;

bekomme ich eine Zugriffsverletzung...?

Grundsätzlich musst du keinen constructor oder destructor einbauen, da du die von TClass erbst. Wahrscheinlich wäre das in deinem Fall aber doch sinnvoll um das script:=TStringList.create unterzubringen.

Wo wird das denn jetzt aufgerufen? Vielleicht liegt da der Grund für die Zugriffsverletzung.

[SearchBot]

Hm...

ein wenig verwirrt bin ich schon.

Ich kann also einfach " = class" schreiben, also nicht zu verwechseln mit " = TClass".
milos sagt, ich müsse con- und destructor einsetzen - er bezieht sich auf class (ohne T).
bcvs sagt, ich benötige kein con/destructor - er bezieht sich auf TClass (mit T).

Ist das der Unterschied zwischen class und TClass?

Meine StringList erzeuge ich hier:

Code:

function TScript.Init(scriptfile: string):boolean;
begin
 result:=false;
 if scriptfile<>'' then begin
  if not assigned(script) then //hier gibts die Zugriffsverletzung
   script:=TStringList.Create;

  if fileexists(scriptfile) then
   script.LoadFromFile(scriptfile);

  result:=script.count>3;

 end;
end;

Einmalig, weil ich beim Einlesen eines anderen Scripts das Ding ja wiederverwenden kann.

Und dort gibts die Zugriffsverletzung, wenn ich class anstelle von object schreibe.
Ich vermute mal, daß es dann daran liegt, daß ich die class nicht .create habe. Grundlegend scheint sie auch ohne zu funktionieren, aber beim Zugriff auf ein nicht initialisiertes ("richtiges") Objekt versagt schon die Frage nach assigned!??

[Sir Rufo]

Mach es doch gleich richtig

Delphi-Quellcode:

type 
  TScript = class
  private
   FLine: word;
   FState: TStatus;
   FLines:TStringList;
   FError:string;
  public
    property Error: string read FError;
    property Lines: TStringList read FLines;
  public
   constructor Create( aScriptFile : string );
   destructor Destroy; override;
  end;

constructor TScript.Create( aScriptFile : string );
begin
  inherited Create;
  FLines := TStringList.Create;
  FLines.LoadFromFile( aScriptFile );
end;

destructor TScript.Destroy;
begin
  FLines.Free;
  inherited;
end;

Kaum ein Unterschied zu object nur dass wir jetzt die Instanz erzeugen (statt Init ) und wieder freigeben (wenn nicht mehr benötigt). Bei der Freigabe räumen wir aber auch den Speicher kontrolliert auf:

Delphi-Quellcode:

procedure Foo;
var
  lScript: TScript;
  lStatus: TStatus;
begin
  lScript := TScript.Create( 'whatever.script' );
  try
    LStatus := Interpreter( '42', TModus.Whatever, lScript ); 
  finally
    lScript.Free;
  end;
end;

[bcvs]

Zitat von SearchBot:

ein wenig verwirrt bin ich schon.

Ich kann also einfach " = class" schreiben, also nicht zu verwechseln mit " = TClass".
milos sagt, ich müsse con- und destructor einsetzen - er bezieht sich auf class (ohne T).
bcvs sagt, ich benötige kein con/destructor - er bezieht sich auf TClass (mit T).

Ist das der Unterschied zwischen class und TClass?

Sorry für die Verwirrung. Ich meinte auch TObject, nicht TClass
type TScript = class ist das selbe wie
type TScript = class(TObject)

Ansonsten: ich habe gerade mal in einem alten TurboPascal-für-Windows-Code nachgeschaut. Das Object kannte doch auch schon Constructoren, nur hießen die da standardmäßig Init. Also hast du ja schon einen Constructor.

Warum und ob dein Init hier:

Delphi-Quellcode:

type TScript = object
  private
   line:word;
   state:TStatus;
  public
   script:TStringList;
   error:string;
   function Init(scriptfile:string):boolean;
end;

als Constructor erkannt wird, weiß ich nicht. Ich würde es so machen:

Delphi-Quellcode:

type TScript = class
  private
   line:word;
   state:TStatus;
  public
   script:TStringList;
   error:string;
   constructor Create;
   destructor Destroy; override;
   function Init(scriptfile:string):boolean;
end;

constructor TScript.Create;
// Hier nur die Stringlist erzeugen
begin
 inherited Create;
 script:=TStringList.Create;
end; 

destructor TScript.Destroy;
// Hier wieder freigeben
begin
  script.free;
  inherited;
end;

function TScript.Init(scriptfile: string):boolean;
// Einlesen des Scriptfiles von der Erstellung der Klasse trennen
begin
 result:=false;
 if scriptfile<>'' then begin
   if fileexists(scriptfile) then
     script.LoadFromFile(scriptfile);
   result:=script.count>3;
 end;
end;

Aufruf dann so:

Delphi-Quellcode:

MyScript:=TScript.Create;
try
  if MyScript.Init(MyScriptFile) then
    MachWas;
finally
  MyScrpit.Free;
end;