According to Thomas Tan:
> When I took a look at objects.pas in the \test\borland_\ directory (a copy
> below), a few questions raise to mind.
> [...]
> Program Objects;(* Bug fixed: objects only worked in units, not in programs.
> *)Type ParentPtr = ^ParentObj; ChildPtr = ^ChildObj;ParentObj = object
> Constructor Init; Destructor Fini; Procedure O; c: Char; [...]
To me, too. Either your mailer's text editor or your "FirstClass SMTP/NNTP
GateWay" or something else has eaten up all line breaks in the source. Or is
this just a joke?
> 1. Does the character c have to be desposed in the destructor?
Of course, not. Only *pointer* variables have to be disposed in the
destructor. This is the same with GPC as with BP.
> If so, is char
> (0) a null character?
It is, although this has nothing to do with `Dispose'.
> 2. If there are variables (character, arrays ,strings, etc) in a function in
> an object, do they have to be manually deleted?
Only if they are pointers.
> If so, how would I erase each one of them?
A modified version of the `objects.pas' test program follows below.
Please note that this is a test program which has the only purpose
of testing whether the OOP mechanisms in GPC work correctly. For
demo programs you can see section "OOP" in the GPC Texinfo online
documentation (`info -f gpc -n OOP'). It's not too detailed, but
it documents how GPC's OOP differs from that of BP. Since these
differences are rather small, any book about "OOP with BP" can help
you with GPC, too.
> 3. Is there such a thing as a pointer to a function?
Yes:
Type
ProcPtr = ^Procedure;
FuncPtr = ^Function ( x: Real ): Real;
If you omit the `^', you have BP's "procedural variables" which work in GPC,
too. (* Here and in my other mails, I am referring to recent beta versions
of GPC, not to the hopelessly outdated gpc-2.0 from December 1996. ;*)
Hope this helps,
Peter
Dipl.-Phys. Peter Gerwinski, Essen, Germany, free physicist and programmer
peter.gerwinski@uni-essen.de - http://home.pages.de/~peter.gerwinski/ [971005]
maintainer GNU Pascal [971001] - http://home.pages.de/~gnu-pascal/ [971005]
8< --------------------------------------------------------------------------
Program Objects;
Type
StringPtr = ^String;
ParentPtr = ^ParentObj;
ChildPtr = ^ChildObj;
ParentObj = object
S: StringPtr;
Constructor Init ( Const SomeString: String );
Destructor Fini;
Procedure O;
c: Char; (* GNU extension: mixing of fields and methods *)
Procedure K; virtual;
end (* ParentObj *);
ChildObj = object ( ParentObj )
Procedure O;
Procedure K; virtual;
end (* ChildObj *);
Var
MyObject: ParentPtr;
Constructor ParentObj.Init ( Const SomeString: String );
begin (* ParentObj.Init *)
New ( S, length ( SomeString ) );
S^:= SomeString;
c:= 'K';
end (* ParentObj.Init *);
Destructor ParentObj.Fini;
begin (* ParentObj.Fini *)
Dispose ( S );
end (* ParentObj.Fini *);
Procedure ParentObj.O;
begin (* ParentObj.O *)
write ( 'O' );
end (* ParentObj.O *);
Procedure ParentObj.K;
begin (* ParentObj.K *)
write ( 'y' );
end (* ParentObj.K *);
Procedure ChildObj.O;
begin (* ChildObj.O *)
write ( 'x' );
end (* ChildObj.O *);
Procedure ChildObj.K;
begin (* ChildObj.K *)
inherited K;
writeln ( chr ( 8 ) + c );
end (* ChildObj.K *);
begin
MyObject:= New ( ChildPtr, Init ( 'Hello, world!' ) );
with MyObject^ do
begin
O;
K;
writeln ( S^ );
end (* with *);
Dispose ( MyObject, Fini );
end.
(* The output should be: *)
(* OK *)
(* Hello, world! *)
Peter Gerwinski (peter@agnes.dida.physik.uni-essen.de)