Delphi-Version: XE
optionale Parameter mit object-type?
Hallo,
ich habe da ein kleines Object aber keine Klasse deklariert:
Code:
Die Interpreter-Function ist sehr umfangreich.
type TScript = object
private line:word; state:TStatus; public script:TStringList; error:string; function Init(scriptfile:string):boolean; end; function Interpreter(cmd:string; Modus:TModus; inScript:TScript):TStatus; Jetzt habe ich manchmal den Fall, daß ich die Interpreter-Function auch ohne "inScript" aufrufen möchte. Ich kann den Parameter aber nicht einfach auf NIL setzen, das läßt der Compiler nicht zu. Ich möchte jedoch nicht nochmal die fast gleiche, umfangreiche Function schreiben und mit OVERLOAD versehen (dann alternativ ohne "inScript"). Wie kann ich auf einfache Weise die Funktion deklarieren, daß der "inScript"-Parameter optional ist? :?: |
AW: optionale Parameter mit object-type?
Zitat:
wie wärs mit nem Overload der dann einfach ein leeres TScript übergibt? Und wozu genau ein object? :D Freundliche Grüsse |
AW: optionale Parameter mit object-type?
Hmm..
wie währe es mit folgender Deklaration
Delphi-Quellcode:
function Interpreter(cmd:string; Modus:TModus; inScript:TScript = nil):TStatus;
Mit dem ' = nil' kann das Object doch einfach beim Aufruf weggelassen werden. Musst dann nur in der implementation der Funktion überall vor Verwendung von inScript auf Assigned prüfen.. |
AW: optionale Parameter mit object-type?
Hallo,
warum lässt der Compiler das nicht zu? Zeig doch mal Deinen Code. |
AW: optionale Parameter mit object-type?
Zitat:
|
AW: optionale Parameter mit object-type?
Zitat:
|
AW: optionale Parameter mit object-type?
Bist du sicher, daß das wirklich so sein soll
Delphi-Quellcode:
und nich so
type TScript = object
Delphi-Quellcode:
?
type TScript = class
In dem Fall würde mich schon der Grund interessieren. |
AW: optionale Parameter mit object-type?
Zitat:
Hab in den ganzen Jahren noch nie object verwendet wüsste auch nicht wozu. :lol: |
AW: optionale Parameter mit object-type?
http://docwiki.embarcadero.com/RADStudio/Berlin/en/Classes_and_Objects_%28Delphi%29#Object_Types"]http://docwiki.embarcadero.com/RADStudio/Berlin/en/Classes_and_Objects_%28Delphi%29#Object_Types"]http://docwiki.embarcadero.com/RADStudio/Berlin/en/Classes_and_Objects_%28Delphi%29#Object_Types
Zitat:
Rollo |
AW: optionale Parameter mit object-type?
das geht wenn Du einen Pointertyp für das Object erzeugst.
Delphi-Quellcode:
und diesen in der function als parameter verwendest. Aber am besten ist es sicher eine Klasse zu verwenden.
PmyObject = ^TmyObject;
|
AW: optionale Parameter mit object-type?
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:
Hierzu sagt der DCC: "E2268 Parameter dieses Typs dürfen keine Standardwerte haben" und steht mit dem Cursor beim nil.
function Interpreter(cmd:string; Modus:TModus; inScript:TScript = nil):TStatus;
Aber mit "
Code:
" -einfach so- funktioniert es, und auch daß ich den Parameter weglassen kann... - Problem gelöst!?
type TScript = class
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:
bekomme ich eine Zugriffsverletzung...?
if not assigned(script) then script:=TStringList.create;
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); |
AW: optionale Parameter mit object-type?
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:
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:
TScript = class
private ... public ... constructor Create; destructor Destroy; override; end;
Delphi-Quellcode:
Danach kannst du in der Funktion abfragen ob inScript gleich nil ist (also ob kein Argument übergeben wurde)
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
Freundliche Grüsse |
AW: optionale Parameter mit object-type?
Zitat:
Delphi-Quellcode:
unterzubringen.
script:=TStringList.create
Wo wird das denn jetzt aufgerufen? Vielleicht liegt da der Grund für die Zugriffsverletzung. |
AW: optionale Parameter mit object-type?
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:
Einmalig, weil ich beim Einlesen eines anderen Scripts das Ding ja wiederverwenden kann.
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; 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!?? |
AW: optionale Parameter mit object-type?
Mach es doch gleich richtig
Delphi-Quellcode:
Kaum ein Unterschied zu
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;
Delphi-Quellcode:
nur dass wir jetzt die Instanz erzeugen (statt
object
Delphi-Quellcode:
) und wieder freigeben (wenn nicht mehr benötigt). Bei der Freigabe räumen wir aber auch den Speicher kontrolliert auf:
Init
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; |
AW: optionale Parameter mit object-type?
Zitat:
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:
als Constructor erkannt wird, weiß ich nicht. Ich würde es so machen:
type TScript = object
private line:word; state:TStatus; public script:TStringList; error:string; function Init(scriptfile:string):boolean; end;
Delphi-Quellcode:
Aufruf dann so:
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;
Delphi-Quellcode:
MyScript:=TScript.Create;
try if MyScript.Init(MyScriptFile) then MachWas; finally MyScrpit.Free; end; |
Alle Zeitangaben in WEZ +1. Es ist jetzt 12:21 Uhr. |
Powered by vBulletin® Copyright ©2000 - 2024, Jelsoft Enterprises Ltd.
LinkBacks Enabled by vBSEO © 2011, Crawlability, Inc.
Delphi-PRAXiS (c) 2002 - 2023 by Daniel R. Wolf, 2024 by Thomas Breitkreuz