Oder kann man das noch besser lösen ?

#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()
{

 addition calc(1,1);   // objekt anlegen und dem konstruktor mit werten initialisieren
 calc.add();   // die funktion add aufrufen

   {
      addition dtor ( NULL,NULL ) ;   // desturktor aufrufen
                                      // der konstrutkor hat 2 parameter also
                                      // braucht der destrutkor auch 2 parameter
   }

 addition s( 2,2);    // konstruktor mit neuen werten initialisieren
 s.add();

 {
      addition dtor ( NULL,NULL ) ; // destruktor erneut aufrufen
 }

system("PAUSE");
}

Darüber hinaus ist dein Code inhaltlich nicht sinnvoll. Die Zeilen 53 und 63 sind völlig sinnlos. Du erzeugst dort neue Objekte mit den Namen dtor, die sofort wieder zerstört werden. Ein Destruktor wird normalerweise am Ende der Lebensdauer eines Objekts automatisch aufgerufen, und man kann ihm auch niemals Argumente übergeben.

NULL ist auch keine Zahl, warum nicht einfach 0?

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.

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

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

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.

Ab wann muss man den denn Destruktor manuell Aufrufen ?

In der Regel garnicht.

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.

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

#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.
*/

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

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

a.~A();

~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

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

Danke für die Hilfen.

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.

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

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.

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.

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

placement delete

Was ist denn das?

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

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

Nein. Das placement new verwendet man meistens nur, um den Ctor explizit aufzurufen. Den Dtor ruft man explizit mit objekt.~Klassenname() auf.

Manchmal verwendet man das placement new auch, um einen Hint zu geben, zum Beispiel wer der später löschenden Thread wohl sein wird oder in der Nähe welchen anderen Speicherblocks man zu liegen kommen mag für mehr Lokalität. So ein Hint ist aber kein richtiger Piratenkodex, sondern mehr so eine Richtlinie. Und gehinteter Speicher mut mit normalem delete wieder freigegeben werden können.

Manchmal benutzt man placement new für memory pooling. Dann braucht man kein delete, weil der Witz ja ist, daß man, sobald die Antwort versichickt wurde, nachher den ganzen Pool wegschmeißt.

Statt pooling kann man's auch machen, um push_back zu beschleunigen-ersetzten ohne perfect forwarding. Leider ist bei Template-Pools der GCC dumm und kann kein placement delete. Aber mit c++0x ist der Druck nicht mehr da, sowas zu machen. Auch hier würde kein delete nötig sein, der z.B. vector das alles auch ohne delete gut managen kann.

Ich erinnere mich noch, daß ich dem delete auch Hints mitgeben wollte. Aber irgendwie ist da auch der Druck weg. Es gibt fettere Tricks um Speed zu machen. Und im besonderen Fall, daß man die Objektgröße haben muß, für den small object allocator, so kriegt man die zum Glück kostenlos oder zu geringeren Kosten als man es per Hand könnte.

Den Operator manuell aufzurufen hat natürlich keinen Sinn, das führt einem den Destruktor ja nicht aus.

inline void *__CRTDECL operator new(size_t, void *_Where) _THROW0()
	{	// construct array with placement at _Where
	return (_Where);
	}

inline void __CRTDECL operator delete(void *, void *) _THROW0()
	{	// delete if placement new fails
	}

(ausm msvc 9.0)

Falls das nicht vorhanden ist (aber man placement new nutzt), gibts auch mindestens ne warning - vll so gar nen error - weiß ich gar nicht mehr genau und bin auch zu faul... ^^

bb

Unterschied: der (placement oder nicht) new Operator besorgt nur Speicher. Eine new Expression ruft den new Operator auf und danach den Konstruktor.

Analog dazu gibt der (placement oder nicht) delete Operator nur Speicher frei. Da es aber nur eine normale delete Expression gibt, nicht aber eine placement Form, kann man über eine delete Expression auch kein placement Delete machen. Wenn man es braucht, muss man erst direkt den Destruktor aufrufen und dann den passenden placement-Delete Operator.

Und ein placement delete Operator muss nicht nichts tun.
Sinnvollerweise sollte der (void*, void*) placement delete Operator nichts tun, da der new (size_t, void*) Operator auch nichts tut.

Du kannst aber jederzeit einen new(size_t, MyAllocator*) Operator basteln, der über MyAllocator Speicher besorgt.
Dazu solltest du dann einen placement delete Operator delete(void*, MyAllocator*) machen, der den Speicher auch wieder brav freigibt. Hier einen "leeren" Operator delete(void*, MyAllocator*) zu machen wäre ein grober Fehler.

@volkard:
Mal abgesehen davon was Sinn macht oder nicht...
Man kann placement new für alles mögliche verwenden. Und da gibt es durchaus Varianten wo man weder das delete einfach weglassen kann, noch das "normale" delete verwenden. Wo man also genau das machen muss, was eine placement delete Expression machen würde, wenn es denn eine gäbe.

Das nächstliegende Beispiel wäre wohl ein auf irgendwas spezialisierter Allokator, dem man ganz "klassisch" die freigewordenen Objekte wieder zurück geben muss.

Wie gesagt, mal abgesehen davon ob es Sinn macht oder nicht. Das ist wieder ein anderes Thema. (Und wie man daraus schliessen kann dass ich nicht wusste dass es keine placement delete Expression gibt, habe ich sowas auch noch nie gebraucht/verwendet).