ich habe ein Klasse die etwa so aussieht:

class Test
{
  public:
    Test()
    {
        this->testVar = new char[200];
    };
    virtual blub(){};

  private:
    char* testVar;
};

Mir stellen sich jetzt 2 Fragen:
1. Muss ich im Destruktor delete this->testVar aufrufen?
2. Wie sieht das mit dem virtuellem Destruktor aus? Wie wird da die auf dem Heap erzeugter char[200] behandelt?

Danke!

1. Muss ich im Destruktor delete this->testVar aufrufen?

ja, es sei denn, du weißt, dass du es nicht tun musst. Allerdings mit dem richtigen Operator:

delete [b][][/b] this->testVar

psih schrieb:

Wie sieht das mit dem virtuellem Destruktor aus? Wie wird da die auf dem Heap erzeugter char[200] behandelt?

nicht anders.

Zu 1.): Genauer: kommt drauf an ...

MfG

class Test
{
    public:
        // Konstruktor: Grundsätzlich Initialisierungsliste verwenden
        Test()
        : testVar(new char[200]) // <- das hier, Member per Komma trennen
        {
        } // kein Semikolon nötig hier

        // Destruktor: Speicher freigeben
        ~Test()
        {
            delete[] testVar;
        }

        // Kopierkonstruktor: Neuen Speicher anfordern und Inhalt kopieren
        Test(const Test& Origin)
        : testVar(new char[200])
        {
            std::copy(Origin.testVar, Origin.testVar+200, testVar);
        }

        // Zuweisungsoperator: Alten Speicher freigeben, neuen anfordern, kopieren
        Test& operator= (const Test& Origin)
        {
            delete[] testVar;
            testVar = new char[200];
            std::copy(Origin.testVar, Origin.testVar+200, testVar);
            return *this;
        }

    private:
        char* testVar;
};

Ich lege dir nahe, etwas Literatur darüber zu lesen, das ist nämlich sehr wichtig. Am Rande sei auch noch das Copy&Swap-Idiom erwähnt, um sicherer zuzuweisen.

Im Normalfall solltest du eher auf die STL-Container und std::string zurückgreifen, als Speicherverwaltung selbst handzuhaben. Im Magazin dieses Forums gibt es ein paar Artikel über die STL, schau dir die vielleicht mal an. Diese ist nämlich ebenfalls ein sehr elementarer Bestandteil von C++.

Test& operator= (const Test& Origin)
        {
            delete[] testVar;
            testVar = new char[200];
            std::copy(Origin.testVar, Origin.testVar+200, testVar);
        }

so schon mal nicht.

Test& operator= (const Test& Origin)
        {
            char* p = new char[200];
            std::copy(Origin.testVar, Origin.testVar+200, p);

            delete[] testVar;
            testVar = p;
            return *this;
        }

Befindet sich ein delete am Anfang der Funktion, ist in 99% der Fälle ein Fehler drin: es ist einerseits nicht exception-sicher und zudem klappt hier auch die Selbstzuweisung nicht.

so schon mal nicht.

Was meinst du? Copy&Swap habe ich erwähnt, das fehlende return *this; war ein Flüchtigkeitsfehler, der auch schon behoben ist.

EDIT:
Weil es halt so verlockend ist etwas zu kopieren, dass läuft, ohne zu überlegen..

Befindet sich ein delete am Anfang der Funktion, ist in 99% der Fälle ein Fehler drin: es ist einerseits nicht exception-sicher und zudem klappt hier auch die Selbstzuweisung nicht.

Exceptionsicherheit bei char ? Ok, std::bad_alloc . Aber angesichts der Tatsache, dass 1. psih wohl schon mit dem normalen Code viel zu lernen hat, 2. ich auf Copy&Swap hingewiesen habe und 3. bad_alloc bei einer Anforderung von 200 char s wohl eher nicht auftritt (Selbstzuweisung ist auch recht selten), habe ich es halt einfach gelöst. Gut, wäre besser gewesen, es gleich richtig zu machen. Ich wollte psih halt nicht überfordern. Bin ich deswegen ein schlechter Mensch?

Bevor man sich um Exceptionsicherheit und ähnliche Dinge kümmert, sollte man meiner Ansicht nach die Grundlagen - Kopiersemantik, Speicherverwaltung und solche Sachen - verstanden haben. Ok, das mit der Selbstzuweisung kann wirklich blöd laufen. Hab ich zuerst gar nicht mehr dran gedacht, da ich eigentlich immer Copy&Swap verwende... Sorry.

drakon schrieb:

Ich würde hier sagen, dass du leicht eine höhere Exceptionsicherheit geben kannst, und darum hätte ich da entweder gleich Copy/Swap implementiert oder es als Kommentar da reingeschrieben, als Aufgabe für den TO.

Steht doch extra da, weil ich solche Antworten befürchtet habe! :p

drakon schrieb:

Ich würde hier sagen, dass du leicht eine höhere Exceptionsicherheit geben kannst, und darum hätte ich da entweder gleich Copy/Swap implementiert oder es als Kommentar da reingeschrieben, als Aufgabe für den TO.

Steht doch extra da, weil ich solche Antworten befürchtet habe! :p

Jup. Das habe ich schon gesehen. Aber ich hätte halt einfach mal eben Copy/Swap gemacht, weil das halt doch recht intuitiv ist und er dann gar nicht auf die Idee kommt im Zuweisungsoperator sonst irgendwelche krumme Sachen zu drehen.

Ich find halt, dass dieses Idiom vor allem für Anfänger doch recht gelegen kommt, weil er dann merkt, dass er sich da überhaupt keine speziellen Gedanken machen muss, sondern eben ganz einfach dem Schema F folgen und das implementieren (auch für andere Klassen).

Naja, dann wird es eben wieder andere Leute geben, die mich des Overengeneerings beschuldigen.

Naja, dann wird es eben wieder andere Leute geben, die mich des Overengeneerings beschuldigen.

Darum hätte ich mich mit einem schlichten:

Test& operator= (const Test& Origin)
        {
          //copy/swap
        }

begnügt.