Konstruktor und Destruktor

hiho,

also den Destruktor rufst du in deinem Programm nirgends manuell auf.

{
      addition dtor ( NULL,NULL ) ;   // Konstruktoraufruf
}

Hierbei erzeugst du ein Objekt namens "dtor" (Konstruktorauruf) und übergibst 2x NULL, damit ist z1=0 und z2=0.

asc

dest schrieb:

Hallo verwende ich den Konstruktor und den Destruktor hier sinnvoll ?

Ich werde mal den (Un-)Sinn der Klasse nicht hinterfragen... Einen Destruktor kannst du in diesem Fall weglassen, und solltest statt einer nachträglichen Zuweisung im Konstruktorrumpf lieber die Initialisierungsliste des Konstruktors verwenden:

addition(int zahl_1, int zahl_2)
: z1(zahl_1),
  z2(zahl_2)
{
}

Ab wann muss man den denn Destruktor manuell Aufrufen ?

Weil hier wird der ja jetzt automatisch aufgerufen.

@asc

Ich werde mal den (Un-)Sinn der Klasse nicht hinterfragen...

Das ist nur eine Übung für mich um zu sehen wie man mit Konstruktoren und Destruktoren arbeiten kann.

#include <iostream>
using namespace std;

class addition
{

private:

      int z1;
      int z2;

 public:

 int add( );

   addition ( int zahl_1 , int zahl_2)  :
        z1 ( zahl_1 ) , z2 ( zahl_2)
   {

   }

   ~addition()
   {
     cout<<"Destruktor"<<endl;
   }

};

 int addition :: add()
 {
 int erg;

        erg = z1 + z2;
        cout<<"Erg: " << erg << endl;

 return erg;
 }

int main()
{    // http://fredosaurus.com/notes-cpp/oop-condestructors/constructors.html

 {
     addition calc(1,1);   // objekt anlegen und dem konstruktor mit werten initialisieren
     calc.add();   // die funktion add aufrufen
 }
  // hier wird der destruktor automatisch aufgerufen

 system("PAUSE");
 }

hiho,

den Destruktor musst du bei der dynamischen Speicherverwaltung (new/delete) indirekt aufrufen, mittels delete bzw. delete[] (bei Arrays) Operator.

Bei allem Anderen braucht dich das nicht zu interessieren,
weil, wie du schon gesagt hast, der Destruktor automatisch,
beim Verlassen des Güligkeitsbereiches, aufgerufen wird.

LordJaxom

dest schrieb:

Ab wann muss man den denn Destruktor manuell Aufrufen ?

In der Regel garnicht.

asc

dest schrieb:

Ab wann muss man den denn Destruktor manuell Aufrufen ?

Als Anfänger kannst du erstmal davon ausgehen: niemals.

Ich behaupte mal das mindestens 95% der C++Programmierer niemals in die Situation kommen, in dem sie ein Destruktor manuell aufgerufen müssen.

asc

Dweb schrieb:

den Destruktor musst du bei der dynamischen Speicherverwaltung (new/delete) manuell aufrufen, mittels delete bzw. delete[] (bei Arrays) Operator.

Selbst da rufst du den Destruktor nicht selbst auf (sondern nur indirekt).

Habe mal ein Beispiel gemacht:

#include <iostream>

class Foo
{
    public:
        ~Foo()
        {
            std::cout << "Destruktor" << std::endl;
        }
};

Foo f_global;
int main()
{
    {
        Foo f_lokal;
    } // <-- f_lokal wird zerstört (automatisch).

    Foo* p = new Foo;

    delete p; // Hier musst du den Destruktor nun indirekt über den delete Operator aufrufen.
    system("pause>nul");
    return 0;
}
// <-- f_global wird zerstört (automatisch).

/*
    Insgesamt wurde der Destruktor nun also 3x augerfuen.
*/

asc

Dweb schrieb:

Habe mal ein Beispiel gemacht:

Und nochmal: Auch hier hast du den Destruktor NICHT manuell aufgerufen. Das delete ihn aufruft ist ein Implementierungsdetail.

// Das wäre ein manueller Aufruf:
A a;
a.~A(); // In der Regel niemals nötig

camper

~a();

Das ist kein expliziter Aufruf des Destruktors.
Ein solcher müsste so aussehen

a.~A();

asc

camper schrieb:

~a();
Das ist kein expliziter Aufruf des Destruktors.
Ein solcher müsste so aussehen
a.~A();

Da merkt man schon wie selten man so etwas braucht

Egal wie selten ich es brauchen werde. ^^

Wenn man weiss wie es geht dann schadet es auch wohl nicht. ^^

Danke für die Hilfen.

Nexus

dest schrieb:

Wenn man weiss wie es geht dann schadet es auch wohl nicht. ^^

Solange man nicht weiss, in welchen Situationen manuelle Destruktoraufrufe sinnvoll sind, nützt einem die Information auch nichts.

asc hat schon Recht. Du fährst besser damit, Destruktoren gar nie direkt aufzurufen.

Hi Nexus,

Nexus schrieb:

dest schrieb:

Wenn man weiss wie es geht dann schadet es auch wohl nicht. ^^

Solange man nicht weiss, in welchen Situationen manuelle Destruktoraufrufe sinnvoll sind, nützt einem die Information auch nichts.

asc hat schon Recht. Du fährst besser damit, Destruktoren gar nie direkt aufzurufen.

Dann lass uns mal an deinem Wissen teilhaben.
In welchen Situationen benutzt man denn manuelle Destruktor-Aufrufe?
Ich habe nämlich auch keine Ahnung
Ich rate mal: Vielleicht wenn man die Speicheranforderungen für new und delete neudefiniert?

Gruß,
CSpille

drakon

CSpille schrieb:

Ich rate mal: Vielleicht wenn man die Speicheranforderungen für new und delete neudefiniert?

Ja. Solche Low Level Sachen.

Man könnte es bestimmt sonst auch noch für diverse schmutze Hacks benutzen.

hustbaer

dest schrieb:

Egal wie selten ich es brauchen werde. ^^

Wenn man weiss wie es geht dann schadet es auch wohl nicht. ^^

Doch kann es schaden.
Wenn du weisst wie, könntest du auf die Idee kommen es irgendwann zu verwenden. Wenn dir irgendwann aber das nötige Hintergrundwissen fehlt, um es richtig zu machen, machst du irgendwann Unsinn.

unskilled

z.Bsp. immer beim zerstören, mit placement new`s erzeugter, objekte...

char* two_objects = operator new[sizeof(T)*2];
T* first  = new(two_objects          ) T(/*ctor-parameter*/);
T* second = new(two_objects+sizeof(T)) T(/*ctor-parameter*/);

/*iwas mit first und second machen*/

first ->~T();
second->~T();

operator delete[] two_objects;

T ist natürlich als template-Parameter zu verstehen...

bb

hustbaer

sollte man mit placement new erzeugte objekte nicht auch mit placement delete wieder freigeben?

LordJaxom

hustbaer schrieb:

placement delete

Was ist denn das?

Dravere

LordJaxom schrieb:

Was ist denn das?

Zu jedem eigenen definiertem placemente new Operator sollte man auch ein placemente delete schreiben:

void* operator new(std::size_t size, Pool& pool)
{
  return pool.alloc(size);
}

void operator delete(void* ptr, std::size_t size, Pool& pool)
{
  pool.dalloc(ptr, size);
}

Der Grund ist der folgende:

class MyClass
{
public:
  MyClass()
  {
    throw std::exception("bum!");
  }
};

Pool pool;
MyClass* myObject = new (pool) MyClass();

Der Konstruktor wirft eine Exception. Damit der angeforderte Speicher vom placement new auch wieder sauber freigegeben wird, muss ein placement delete existieren.
Wenn man das Ding übrigens manuell aufrufen will, dann geht dies nur so:

operator delete(myObject, pool);

hustbaer schrieb:

sollte man mit placement new erzeugte objekte nicht auch mit placement delete wieder freigeben?

Man hat im placement delete Operator allerdings keine Typinformationen mehr, daher kann man keinen Destruktor mehr aufrufen. Dies muss irgendwie davor geschehen.

Grüssli