> On Mar 8, 2018, at 2:43 PM, Ryan Joseph <r...@thealchemistguild.com> wrote:
>
> In many cases I don’t actually need anything on the heap and a record could
> be used instead but because of limitations on records in Pascal I need a full
> class. Doing the ARC route is just solving a problem I created by the fact I
> used a class instead of a record in the first place. c++ solves this by
> letting you keep the class on the stack or the heap depending on how you want
> it’s memory managed. That was a superior choice in my opinion but I
> understand implementing that in Pascal would be a massive overhaul and
> probably not worth it.
Just an example to illustrate the stupid things we do everyday without
realizing it.
TList keeps some memory allocated on the heap (GetMem) and needs to be freed at
the end of it’s life cycle. The class itself has an integer and a pointer (6
bytes). In the function we call TList.Create which allocates some memory from
the memory manager for the 6 bytes. We add some values to the list and modify
it’s internal memory (which is actually dynamic so that’s a good usage) then
when the function ends we call free.
Problems:
1) We interface with the memory manager twice here and the 2nd time for a
measly 6 bytes which we knew at compile time anyways (dynamic memory manager
for static data??).
2) We need to remember to call Free() at the end of the function and take
precaution to not exit early and leak memory (maybe even using a goto to break
out of nested loops or nested functions, who knows).
Even using an ARC/garbage collecting approach for this is just stupid and a
waste of resources. I know I need the TList members on the stack at compile
time (integer + pointer) so why am I doing all this dynamic memory management
stuff? It’s still important to use a class though because maybe I need
inheritance and heap allocation for other use cases.
type
TList = class
private
count: integer;
data: pointer; // pointer to some memory on heap
public
procedure Add (value: pointer);
end;
procedure MyProc;
var
list: TList;
begin
list := TList.Create;
list.Add(x);
...
list.Free;
end;
The more efficient approach would clearly be something like:
procedure MyProc;
var
list: stack TList; // assume this allocates us on the stack like a
record
begin
list.Clear; // there’s no Create call so init the class some how
list.Add(x);
// Free() is called when MyProc goes out of scope
end;
Regards,
Ryan Joseph
_______________________________________________
fpc-pascal maillist - fpc-pascal@lists.freepascal.org
http://lists.freepascal.org/cgi-bin/mailman/listinfo/fpc-pascal
