Warum Delphi-Klassen auf dem Heap erstellt werden müssen

1. TObject
2. Konstruktion und Destruktion
3. Virtuelle Funktionen in Konstruktor und Destruktor
4. Exceptions im Konstruktor
5. Initialisierung
6. Mehrfachvererbung
7. Virtuelle Konstruktoren
8. Klassenfunktionen
9. Freigabe
10. Semantik
11. Benutzung
12. Syntax für temporäre Stack-Objekte
13. Allokation und Deallokation
14. RTTI
15. Implizit generierte Methoden
16. Kommentare

void foo (void)
{
    TStringList sl;
    ...
}

TObject

Konstruktion und Destruktion

Virtuelle Funktionen in Konstruktor und Destruktor

struct Base
{
    virtual void foo (void) = 0;
    Base (void) { foo (); }
};
struct Derived : Base
{
    virtual void foo (void) { ShowMessage ("It's me!"); }
};

struct TBase : TObject
{
    virtual void foo (void) = 0;
    TBase (void) { foo (); }
};
struct TDerived : TBase
{
    virtual void foo (void) { ShowMessage ("It's me!"); }
};

void bar (void)
{
    TDerived* td = new TDerived; // zeigt "It's me!" an
    Derived d; // zeigt "Pure virtual function called" an
}

Exceptions im Konstruktor

Initialisierung

Mehrfachvererbung

Virtuelle Konstruktoren

Klassenfunktionen

Freigabe

Semantik

procedure foo;
var
  sl1, sl2: TStringList;
begin
  sl1 := TStringList.Create;
  sl2 := sl1; // diese Zeile
  ...

Benutzung

void foobar (void)
{
    TStringList* sl = 0;
    try
    {
        sl = new TStringList;
        ...
    }
    __finally
    {
        delete sl;
    }
}

#include <memory>

void foobar (void)
{
    std::auto_ptr <TStringList> sl (new TStringList);
    ...
}

#include <memory> // TR1-Unterstützung seit C++Builder 2009
#include <vector>

typedef std::tr1::shared_ptr <TStringList> TStringListPtr;

TStringListPtr stringListFactory (void)
{
    TStringListPtr result (new TStringList);
    result->Add ("Initial string");
    return result;
}

void foobaz (void)
{
    std::vector <TStringListPtr> slv;
    slv.push_back (stringListFactory ());
    ...
}

#include <memory>

TStringList* stringListFactory (void)
{
    std::auto_ptr <TStringList> result (new TStringList);
    result->Add ("Initial string");
    return result.release ();
}

void foobaz (void)
{
    std::auto_ptr <TStringList> theStringList (stringListFactory ());
}

Syntax für temporäre Stack-Objekte

class TMyThread : public TThread
{
protected:
    virtual void __fastcall Execute (void) {}

public:
    TMyThread (void) : TThread (false) {}
};

void startMyThreadTheFreakyWay (void)
{
    TMyThread ().FreeOnTerminate = true;
}

void startMyThreadTheNormalWay (void)
{
    new TMyThread ()->FreeOnTerminate = true;
}

Allokation und Deallokation

#include <string>

void constructSomeObjects (void)
{
        // Allokation auf dem Stack
    std::string myStackString ("foo");
    myStackString += std::string ("bar");

        // Allokation auf dem Heap
    std::string* myHeapString = new std::string ("baz");
    delete myHeapString;

        // Explizite Konstruktion und Destruktion
    char buffer[sizeof (std::string)];
    std::string* anotherStackString = new (buffer) std::string ("wtf?");
    anotherStackString->~string ();
}

class MyCppClass
{
public:
    void* operator new (unsigned long size)
    { return std::malloc (size); }
    void operator delete (void* ptr)
    { std::free (ptr); }

    virtual ~MyCppClass (void) {}
};

class TMyCustomAllocatedClass : public TObject
{
public:
#ifdef __CODEGEARC__ // C++Builder 2009 unterstützt Klassenmethoden
    __classmethod virtual TObject* __fastcall NewInstance (void)
    {
        void* memory = std::malloc (InstanceSize ());
        return InitInstance (memory);
    }
#else
    virtual TObject* __fastcall NewInstance (TMetaClass* Self)
    {
        void* memory = std::malloc (Self->InstanceSize ());
        return Self->InitInstance (memory);
    }
#endif
    virtual void __fastcall FreeInstance (void)
    { std::free (this); }
};

  // System.pas, 263ff
  { Hidden TObject field info }
  hfFieldSize          = 4;
  hfMonitorOffset      = 0;

RTTI

Implizit generierte Methoden

class ClassWithProperties
{
private:
    int FFoo;
    String FBar;

public:
    __property int Foo = { read = FFoo, write = FFoo };
};

Referenzen

Kommentare