class myclass
{
  friend operator new;
 private:
  myclass();
}

So kann man Leute zwingen, Objekte auf dem Heap anzulegen. Was das bringen soll, kann ich nicht nachvollziehen *böse zu VCF guck*

Foo* foo = create_foo(bar, baz);
foo->destroy();
// oder:
delete foo; // Wenn du dich auf new/delete festlegen willst.

Gruß
Don06

Hallo.
Wie kann ich verhindern, dass ein Objekt auf dem stack erzeugt wird?

Wenn ich dies aus irgendeinen Grund brauche, sieht es bei mir meist in etwa wie folgt aus:

#include <memory> // TR1 Header, bzw. <boost/shared_ptr.hpp> oder vergleichbares

class MyClass
{
    public:
        static std::tr1::shared_ptr<MyClass> Create()
        {
            return std::tr1::shared_ptr<MyClass>(new MyClass);
        };

    private:
        MyClass();
        MyClass(MyClass const &); // Dieser muß auch unterbunden werden...
        // und über den Zuweisungsoperator solltest du dir auch Gedanken machen
};

Am besten auch eine Freigabefunktion, dann kannst du dir aussuchen, wie du den Speicher allokierst.

Ich würde sowas von Smartpointern etc. übernehmen lassen. Alles was man separat aufrufen muß, verleitet dazu vergessen zu werden.

An sowas hatt ich auch schon gedacht.
Wollt es eigendlich mit dem new operator machen.
Wenns aber nicht funktioniert ist es auch nicht so schlimm.

Das Problem ist, dass Objekte, die mit new erstellt werden, eigentlich gerade so gut auf dem Stack als automatische Variablen deklariert werden können.

Aus reiner Neugier: Wofür brauchst du das?

Aus reiner Neugier: Wofür brauchst du das?

Ich wollte in einer Funktion

delete this;

benutzen. Deswegen darf auf gar keinen Fall ein Objekt auf dem Stack abgelegt werden.

Möglicherweise gibt es auch eine bessere Lösung für das, was du tun willst. Es ist wahrscheinlich auch verwirrend für den Anwender, wenn er das Objekt mit new erstellt, dieses sich aber selber per delete löscht (nur so nebenbei)...

Nexus schrieb:

Aus reiner Neugier: Wofür brauchst du das?

Ich wollte in einer Funktion

delete this;

benutzen. Deswegen darf auf gar keinen Fall ein Objekt auf dem Stack abgelegt werden.

Dann ist auch der shared_ptr nichts für dich.

Die überlegungen zu "delete this" kenne ich eigentlich nur bei dem anlegen nicht-modaler Fenster...

cu André

class bar;

class inerface_foo{
  friend class bar;
 protected:
  virtual void message(string& nonsense)=0;
  virtual ~interface_foo();
};

Wobei irgendeine Funktion von bar in einer großen Schleife message aufruft.
Der "Anwender" soll von interface_foo erben und darf dann mit

if (verarbeite(nonsense)==error)
{
  delete this;
  return;
}

sein Objekt zerstören.

Dann könntest du in interface_foo eine bool -Variable als Flag deklarieren, die anzeigt, ob der Zustand gültig ist oder nicht. Oder du gibst direkt der Funktion message() den Rückgabetypen bool . So kann der Aufrufer sehen, ob das Objekt noch weiterexistieren soll. Verstehst du, was ich meine?