Automatische Freigabe von Objekten in C++Builder im Vergleich zu Delphi

[mjustin]

Im DocWiki habe ich diesen Artikel gefunden

http://docwiki.embarcadero.com/RADSt...ung_in_C%2B%2B

Darin wird unter anderem auch eine automatische Freigabe von Speicher beschrieben, allerdings nur für ARC.

Meine Frage: ist es bei Desktop Anwendungen (also ohne ARC) im Gegensatz zu Delphi nicht möglich, Interface-Referenzzählung (z.B. über TInterfacedObject) zur automatischen Objektfreigabe zu verwenden?

[Sir Rufo]

Die lassen sich in dem Artikel doch gar nicht explizit zu Interfaces aus ... logisch, weil Interfaces mit ARC nichts am Hut haben.
Ja, da spielt was mit rein, aber das Verhalten von einem Interface bleibt gleich - evtl. bis auf TInterfacedPersistent .

[mjustin]

Zitat von Sir Rufo:

Die lassen sich in dem Artikel doch gar nicht explizit zu Interfaces aus ... logisch, weil Interfaces mit ARC nichts am Hut haben.
Ja, da spielt was mit rein, aber das Verhalten von einem Interface bleibt gleich - evtl. bis auf TInterfacedPersistent .

Das klingt gut - ich verwende auch nur TInterfacedObject um die automatische Freigabe zu erreichen.

Unter Delphi und Free Pascal klappt es, ein "abenteuerlustiger" C++Builder stellte un jedoch Memory Leaks fest.

Ich vermute daher, dass die Freigabe nicht in gleicher Weise genutzt werden kann. C++Builder dafür zu installieren wäre jedoch etwas für einen langen Winterabend. Vielleicht ist das eine gute Frage für StackO ...

[mensch72]

D2009... also dann auch CB2009?... da war manches noch sehr seltsam.

pures C++ funktioniert, und wie früher bei C benötigt die Rückgabe von Zeigern da immer höchste Aufmerksamkeit... gut wenn man kontrolliert selbst dafür sorgt, jeder "Exit" Weg unabhängig ob gewollt oder per Exeption die sich um die Freigabe aller Sachen selbst bewusst kümmert.

Das über mit Interfaces indirekt zu lösen habe ich nie gemacht, habe mich immer für den selbst kontrollierten/programmierten Weg entschieden.

In C++ gehen für sowas aber alternativ auch ein paar Sachen, die in Delphi so nicht gehen...

void MyFunc(void)
{
TMySimpleClass x; // X: AutoCreate und ConstructorCall

x.MyMethod();

} //X: DestructorCall und AutoFree

Bei Delphi kann ich Klassen nur dynamisch mit explizitem "new/create" anlegen...
In C++ kann man wie in Delphi bei Records auch einfache Klassen auf dem lokalem Heap vom Compiler anlegen lassen, welche der Compiler dann auch selbst aufräumt... (Man erkennt ja auch die Art der Erzeugung bei Compiler-Verwaltung an der Nutzung vom "Punkt" anstatt vom "Pfeil" beim Memberzugriff)

DelphiLike "AutoFreigabe in C++Builder" mag schön sein, aber wenn C++Builder dann doch lieber so nah wie möglich am puren C++ bleiben, der C++ Code mit VCL Verwendung ist eh seltsam und unportabel genug. Wer mal etwas mehr C++Builder Source in einem VisualC++ Project weiternutzen wollte, weiß das man da ohne einige freie VCL "Ersatz"-Libs kaum sinnvoll was nutzen kann, weil die PAS RunTime woanders nix nützt.

=> Daher will ich gar nicht wissen, ob&wie die DelphiLike AutoFreigabe funktioniert, außer jemand kann sagen wie es in VC++ und C++Builder einheitlich und damit universell geht?

[himitsu]

Klingt nett. Selbst in Pascal wird es schon schwer und wenn man das hier lieft.

Die Interface-Referenzzählung wird im ARC standardmäßig auf die ARC-Referenzen des internen Objektes umgeleitet. Ich vermute/hoffe einfach mal, daß es im C++ genauso bemacht wurde.
Es gäbe also keinen Unterschieg, ob in einem System mit ARC, eine Referenz auf das Interface oder auf das interne Objekt existiert.




Das Problem beschäftigt mich schon seit paar Jahren immer mal wieder.

Vorallem in Bezug auf Kreuzreferenzen zwischen zwei und vorallem mehreren Objekten.

Parent kennt seine Kinder, die Kinder und Kindeskinder ihre Parents und ohne daß sie sich alle gegenseitig im Speicher halten, wenn alle externen Referenzen freigegeben sind, sollen die Eltern nicht verschwinden, selbst wenn nur noch eine Referenz auf ein Kind existiert.

Weak-Referenzes hätte man auch gleich mal überall einbauen können, wenn man schon dabei ist, selbst wenn es dort noch kein ARC gibt.


Mein Fazit: Es ist nahezu unmöglich einen (größeren) Code zu scheiben, welcher in allen Plattformen problemlos zu verwenden ist, ohne viel Arbeit und ohne das in jedem System einzeln zu testen, anzupassen und wieder alles zu testen.
Und ständig muß man mit irgendwelchen blöden Kompromissen leben. (wenn man nicht überall seinen Produktiv-Code mit tausenden IFDEFs vollpflasteren will)

Die berühmte Abwärtskompatibilität und alles funktioniert in Jahrzehnten immernoch, hat sich damit erledigt.
Für Delphi (vorallem Windows) hab ich mir jetzt Weak-Referenzes selbet gebaut und hoffe die funktionieren überall so, wie ich es mir denke, auch mit ARC und Co.

[Insider2004]

Vorsicht mit FPC: TInterfacedObject funktionieren in FPC gänzlich anders und sind völlig inkompatibel zu Delphi.

[NicoDE]

Zitat von Insider2004:

Vorsicht mit FPC: TInterfacedObject funktionieren in FPC gänzlich anders und sind völlig inkompatibel zu Delphi.

Inwiefern sind sie denn inkompatibel. Beide implementieren IUnknown, welches die Referenzzählung (und automatische Freigabe) einführt.