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
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>

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 ());
}

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) {}
};

  // 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