I had another idea and I was just curious what anyone thought about it. Between
C++ where classes can either be on the stack or heap and full ARC like in
Swift/Java FPC is kind of in the middle with a unified heap-only class system
which is easier to use than C++ (classes are always pointers so need to worry
about pointer indirection all the time) but creates lots of garbage memory you
need to manage yourself (no ARC/garbage collector unless you count ref counted
interfaces).
My idea is to keep the FPC class as is but introduce a keyword that allocates
the classes memory on the stack upon declaration. Then we you call Create like
you normally would, instead of getting a new chunk of memory from GetMem the
class internally references the pointer on the stack. Finally when the scope
terminates it calls the destructor in a recursive process on all local
variables (or class members) that are stack alias.
The benefits are:
1) Easy to implement since it just overrides GetMem with another pointer
2) Transparent to switch between heap vs stack since the class is always a
pointer so no copying on pas and, pointer indirection, like c++ classes on the
stack or Objects in Pascal (objects are missing features anyways and allocating
on the stack still uses new() ). FPC is even worse than C++ in this regard
because switching between class vs object is a real mess and just not practical.
3) More performant since we don’t need to allocate memory on the heap which we
already know will be needed at compile time anyways. Doesn't require a runtime
for garbage collecting and doesn’t allocate memory on the heap behind the
scenes like Swift and full ARC systems probably do.
What do you think? Is there any merit to this idea? It’s not real reference
counting but it’s a simple solution to improve performance and clean up code in
many common scenarios.
type
TMyClass = class
child: TObject; stackalias;
constructor Create; override;
destructor Destroy; override;
end;
constructor TMyClass.Create;
begin
child := TObject.Create;
end;
destructor TMyClass.Destroy;
begin
// all stack alias members call destructor here
end;
var
parent: TMyClass; stackalias; // memory is reserved on the stack for
sizeof(TMyClass)
begin
parent := TMyClass.Create; // constructor still works like normal but
internal pointer points to @parent
// all stack alias local variables call destructor at end of scope
end;
Regards,
Ryan Joseph
_______________________________________________
fpc-pascal maillist - [email protected]
http://lists.freepascal.org/cgi-bin/mailman/listinfo/fpc-pascal
