optionale Parameter mit object-type?

[SearchBot]

Interessante Anregungen und gute Links, vielen Dank Rollo62.
Versuche das mal zu erklären....

Ich hab damals mit TurboPascal 6.0 angefangen, dann 7.0 danach mal kurz bei Pascal für Windows 1.0 reingeguckt und lange Zeit (bis Delphi XE mal günstig angeboten wurde) mit Delphi 4.0 gearbeitet.
Ich hab also nicht jede Entwicklung mitbekommen, wie man was heutzutage korrekt verwendet. Mit object bin ich immer gut gefahren während Klassen, deren Pointern und Konstrukt- und Destruktoren, propertys und read/write... meinen einfachen Verstand übersteigen.
Ich hab schon 2x versucht, mit den gedruckten Entwicklerhandbüchern mich in Klassen und Komponenten-Entwicklung einzuarbeiten und bin jedesmal bei der Vererbung frustriert stecken geblieben - vielleicht auch, weil die Abhandlung für mein jeweiliges Projekt nicht zielführend und dem zeitsparenden Gedanken des RAD entgegen stand.
Ich habs dann jeweils aufgegeben und mich mit einfachen Objektentypen (record, object) zufrieden gegeben, denn das hat ja funktioniert und ich vermeide langwährende Fehlersuchen, weil ich irgendwo eine AccessViolation bekomme :roll:

Aber ich lerne gerne dazu, wenns nicht allzu abstrakt ist...
Das also dazu, warum ich object anstelle von class nutze (übersichtlich, Denkstruktur).

Jetzt also mal so

Code:

function Interpreter(cmd:string; Modus:TModus; inScript:TScript = nil):TStatus;

Hierzu sagt der DCC: "E2268 Parameter dieses Typs dürfen keine Standardwerte haben" und steht mit dem Cursor beim nil.

Aber mit "

Code:

type TScript = class

" -einfach so- funktioniert es, und auch daß ich den Parameter weglassen kann... - Problem gelöst!?

Was macht der Compiler denn da unter der Motorhaube anders?
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...?

Wäre der leichte Weg wohl eher (entsprechend der Anregung von milos), daß ich einen Dummy deklariere und in der Funktion prüfe, ob dort was sinnvolles drinsteht:

Code:

var dummy:TScript;
begin
   State:=Interpreter(script[line],mSingle,dummy);

[milos]

Ja also wie bereits gesagt wurde, object ist veraltet und sollte nicht mehr benutzt werden, was dich aber natürlich nicht abhält das trotzdem zu tun wenn du willst. Jedoch würde ich empfehlen einfach eine richtige Klasse draus zu machen, ist ja nicht kompliziert oder so ^^

Ich denke du kannst im Grunde genommen einfach das object mit class ersetzen.
Und ja du hast einen Konstruktor und Destruktor. In denen musst du erstmal die Objekte erstellen und schlussendlich diese auch wieder aus dem Speicher löschen.
Warum du da genau eine Zugriffsverletzung bekommst, weiss ich nicht liegt wohl an ner anderen Stelle im Code oder bin gerade zu müde um es zu sehen :D Kann es vielleicht sein das der Destruktor falsch ist und/oder du das script Objekt vorher mal "free"'st? Kenne das von früher, dass ich ab und zu an falschen Stellen die Objekte aus dem Speicher entfernt habe und deswegen Zugriffsverletzungen auftraten.

Im Grunde genommen sollte deine TScript Klasse schlussendlich genau gleich bleiben ausser halt mit class-Eigenschaften:

Delphi-Quellcode:

TScript = class
private
  ...
public
  ...
  constructor Create;
  destructor Destroy; override;
end;

und dann könntest du ganz einfach für die Funktion Interpreter den Standardwert von inScript auf nil setzen und den dann bei der Funktion abfragen und entsprechend reagieren oder nen Overload setzen. Die erste Möglichkeit ist meiner Meinung nach einfacher zu verstehen, wäre dann etwa so:

Delphi-Quellcode:

function Interpreter(cmd:string; Modus:TModus; inScript:TScript = nil):TStatus; // Beachte das = nil hinter inScript:TScript welches angibt das inScript gleich nil ist wenn kein Argument übergeben wurde

Danach kannst du in der Funktion abfragen ob inScript gleich nil ist (also ob kein Argument übergeben wurde)

Freundliche Grüsse

[bcvs]

Zitat:

Zitat von SearchBot (Beitrag 1338433)

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

Delphi-Quellcode:

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

Delphi-Quellcode:

object

nur dass wir jetzt die Instanz erzeugen (statt

Delphi-Quellcode:

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:

Zitat von SearchBot (Beitrag 1338477)

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 :oops:
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;