4 ms·
No. Delphi offers reference counting, but only on interface variables. It's a huge difference really, because if your last interface variable that points to an
by undreren 9y ago
No. Delphi offers reference counting, but only on interface variables. It's a huge difference really, because if your last interface variable that points to an object goes out of scope, the object is freed from memory. Even if you have raw class pointers to it.
Example:
IMyInterface = interface
procedure Foo;
end;
TMyClass = class(TInterfacedObject, IMyInterface)
procedure Foo;
end;
procedure TMyClass.Foo;
begin
WriteLn('Foo');
end;
procedure DoTheFoo(AObj: IMyInterface);
begin
AObj.Foo;
end;
procedure SomeMethod;
var
LObj: TMyClass;
begin
LObj := TMyClass.Create;
DoTheFoo(LObj);
LObj.Foo; // <-- Will cast nil pointer exception,
// as object was freed when AObj in DoTheFoo went
// out of scope
end;
I work with Delphi in my day job.
- klipt 9y agoOh, in that case that's no better than C++'s shared_ptr. I remember Delphi being fun back in the day and it still compiles way faster than C++, but C++ is evolving and maybe with modules even the compilation speed gap will disappear...
- undreren 9y agoI actually feel that shared_ptr is a better fix, because that makes the memory handling consistently opt-in, instead of inconsistent.
- MageSlayer 9y agoI highly doubt it's production code. Nobody uses both objects(pointers) and interfaces simultaneously. It's a quick way to disaster. In practice Delphi/FPC interfaces serve their purpose.
- pjmlp 9y agoFor those lacking CS background, reference counting is an GC algorithm. The 5th chapter from "The Garbage Collection Handbook", http://gchandbook.org/ http://gchandbook.org/, one of the most renowned books in the field, there are of course other equally renowned sources I can refer to.
- zerr 9y agoFormality aside, it's about deterministic GC vs nondeterministic GC.
- pjmlp 9y agoReference counting isn't deterministic in the presence of large complex data structures. You will know when memory gets deleted, but not how long it will take, nor how much stack space the destructors will require to run. Enjoy Herb Sutter's "Leak-Freedom in C++... By Default." at CppCon 2016, where he explains how those issues affect C++ and goes on to implement a tracing GC. https://www.youtube.com/watch?v=JfmTagWcqoE https://www.youtube.com/watch?v=JfmTagWcqoE
- Jack4E4B 9y agoSwift also does Reference counting, the difference is huge. Speed of code is in another level. I am new to Lazarus, but I am guessing they do the same as Delphi.
- TimJYoung 9y agoYou would never code the SomeMethod like that, you would use this instead: var LObj: IMyInterface; begin LObj := TMyClass.Create; DoTheFoo(LObj); LObj.Foo; end;