Habe in einer Klasse einen Zeiger, den ich aber auf jedenfall freigeben möchte. Was haltet ihr von folgendem Vorgehen?

class Foo
{
public:
//...
private:
    void init_bar();
    Bar* m_bar;
    int m_x;
    int m_y;
//...
};

Foo:Foo()
: m_x( 0 ), m_y( 0 )
{
    std::cout << "C'tor" << std::endl;
    m_bar = new Bar( 0, 0 );
    std::cout << "    new Bar in C'tor" << std::endl;
    init_bar();
}

Foo::~Foo()
{
    std::cout << "D'tor" << std::endl;
    if( bar )
    {
        std::cout << "    delete Bar in D'tor" << std::endl;
        delete bar;
        bar = 0;
    }
}

void Foo::init_bar()
{
    std::cout << "Init Bar" << std::endl;
    if( bar )
    {
        std::cout << "    delete Bar in Init Bar" << std::endl;
        delete bar;
        bar = 0;
    }
    std::cout << "    new Bar in Init Bar" << std::endl;
    bar = new Bar( m_x, m_y );
}

void bla(Foo f){
  // tu was mit f;
}

int main(){
   Foo f;
   bla(f);
   //tu was mit f; OOpps Zeiger wurde ja schon gelöscht! (von der Kopie!)
}

BR
Vinzenz
//Edit: Ja saperalot da hab ich doch die code tags vergessen^^

class Foo
{
public:
//...
private:
    void init_bar();
    Bar* m_bar;
    int m_x;
    int m_y;
//...
};

Foo:Foo()
: m_x( 0 ), m_y( 0 )
{
    m_bar = new Bar( 0, 0 ); // ok, du erstellst ene neue Bar
    init_bar();
}

Foo::~Foo()
{
    if( bar )  // ist für die Katz, da bar an dieser Stelle garantiert nicht 0 sein kann.
    {
        delete bar;
        bar = 0;  // Für die Katz, da bar nach dem Rücksprung
                  // aus dem d-tor sowieso nicht mehr existiert
    }
}

void Foo::init_bar() // diese Methode wird nur im c-tor aufgerufen.                    
{                    // Wesshalb erstellst du sie nicht in ihm korrekt mit m_x und m_y??
                     // Was hat es für einen Sinn, absichtlich eine Instanz anzulegen,
                     // sie zu löschen und erneut anzulegen??

    if( bar ) // für die Katz, da delete 0-Pointer sowieso in Ruhe lässt
    {
        delete bar;
        bar = 0;
    }
    bar = new Bar( m_x, m_y );
}

Du hast übrigens die Deklaratinen des c-tors und des d-tors in der Klassendeklaration vergessen.
Warum machst du nicht einfach:

Wenig, denn ich kann den Sinn nicht erkennen (Ausgaben entfernt):

class Foo {

    public:

        Foo( );
        Foo( int x, int y );
        ~Foo( );

    private:

        Bar* m_bar;
        int m_x;
        int m_y;
};

Foo:Foo( ) : m_x( 0 ), m_y( 0 )
{
    m_bar = new Bar( 0, 0 );
}

Foo::Foo( int x, int y ) : m_x( x ), m_y( y )
{
    m_bar = new Bar( m_x, m_y );
}

Foo::~Foo()
{
    delete m_bar;
}

?!

Greetz, Swordfish

class Foo {

    public:

        Foo( );
        Foo( int x, int y );

    private:

        int m_x;
        int m_y;
        Bar m_bar;
};

Foo:Foo( ) : m_x( 0 ), m_y( 0 ), m_bar(0, 0)
{ }

Foo::Foo( int x, int y ) : m_x( x ), m_y( y ), m_bar(x, y)
{ }

Da brauchst du keinen Pointer und brauchst dich nicht um die Allokation und Deallokation kümmern. So nebenbei wird auch der default Kopier- und Zuweisungsoperator funktionieren. Und schneller ist das ganze auch noch.

Ein Objekt, welches im Konstruktor angelegt und im Destruktor wieder frei gegeben wird, muß nicht dynamisch allokiert werden. Zeiger werden eigentlich viel zu oft verwendet. Ich verwende sie eher selten.

Ach ja - wenn Du jetzt für irgendeinen Funktions- oder Methodenaufruf einen Zeiger auf Bar als Parameter benötigst, bekommst Du ihn mit &m_bar.

Tntnet

Wenn du das trozdem mit new und delete machen willst, ist es wohl das einfachste für dich die SmartPointer aus der Boost-Lib zu benutzen. Diese Pointer geben sich selbst frei, wenn sie nicht mehr gebraucht werden. Oder im d-tor einfach prüfen welche Zeiger deiner Klasse ungleich 0 sind und diese dann mit delete Freigeben. (Das setzt natürlich voraus, das du die Zeiger beim vorzeitigem löschen auch auf 0 setzt)

Eigentlich sollte Bar aber einen Standardkonstruktor haben, so das du das ganze auch ohne Parameter initaliesieren kannst.

Bar ist nicht von mir, die Klasse will ich adaptieren/wrappen. Die hat zwar einen Defalut C'tor, dann ist m_bar aber logischerweise leer, und ich muss alle Elemente einzeln über eine Iterator Schlaufe (wie bei STL Containern) einfüllen. Das bedeutet dann eine x-fache Speicherreallocation, da Bar intern mit Arrays arbeitet. Effizienter wäre, dem C'tor Anfangs- und Enditerator zu übergeben, denn dann nimmt Bar die Elemente direkt rüber in die eigenen Datenfelder, was scheints optimiert wurde.

// Also statt:
Bar m_bar;
for( it = it_begin; it != it_end; it++ )
{
    Bar::add_element( *it, m_bar );
}

// einfach so:
Bar m_bar( it_begin, it_end );

Oder im d-tor einfach prüfen welche Zeiger deiner Klasse ungleich 0 sind und diese dann mit delete Freigeben. (Das setzt natürlich voraus, das du die Zeiger beim vorzeitigem löschen auch auf 0 setzt)

Wesshalb nach einem "vorzeitigem" delete pointer dem pointer 0 zuweisen und im d-tor vor dem delete pointer auf pointer != 0 prüfen!?

Tipp: delete lässt 0-Zeiger in ruhe

Greetz, Swordfish

Tipp: delete lässt 0-Zeiger in ruhe

Warum macht DirectX dann immer diese SAFERELEASE Konstrukte?
Da wirds doch genau so gemacht?

if( LPDIRECTXIRGENDWAS )        // LongPointer auf DXInterface, typedef für pointer
{
    LPDIRECTXIRGENDWAS->release();   // Wohl ein Wrapper für delete oder nicht?
    LPDIRECTXIRGENDWAS = 0;
}

LPDIRECTXIRGENDWAS->release();   // Wohl ein Wrapper für delete oder nicht?

oder.

das ist ein aufruf einer memberfunktion - und das ist nur legal, wenn LPDIRECTXIRGENDWAS auf ein lebendes objekt zeigt. dass release() ganz nebenbei evtl. noch für das löschen zuständig ist, spielt dabei keine rolle.

grüße

Die Initialisierungsliste bietet u.A. den Vorteil das der C'tor Rumpf ggf nicht extra aufgerufen werden muss und dein Objekt nicht mit Defaultwerten vollgepumpt wird.

grüße

Etwa so meinst Du?

In dem Fall kannst du auf den Aufruf von init_bar verzichten.

new Bar( 0, 0 ) wollt ich eben eigentlich gern vermeiden..

ich habe mal eine ganz andere Frage: Wenn Foo eine Wrapperklasse von Bar sein (und Bar mit ihr sterben) soll, warum soll sie dann früher ins Leben gerufen werden als Bar ?

Oder hast Du eigentlich etwas Anderes vor, nämlich, dass FooBar ein Bar verwaltet (=komplett aggregiert und "Besitz übernimmt") ?
In dem Fall kann ich kein echtes Problem in Deinem ursprünglichen Vorgehen sehen. Du verwaltest im Pointer Bar* bar; im Grunde 2 Informationen:
1. Ob bar schon initialisiert wurde ("bar != 0") und
2. Wenn schon initialisiert: Wo die Daten liegen.
Dann ist ein "Foo(...) : bar(0), ... {...}" konsequent (also nicht ein leeres Objekt erzeugen).

Allerdings stimmt schon: Du musst Dich um "Kopieren" (copyCtr, operator=()) kümmern, um Speicherlecks bzw. Doppeltlöschungen zu verhindern.
- Einfachstes: Kopieren verbieten (copyCtr und operator=() private machen) => STLContainer funktionieren nicht mehr ... aber das kann durchaus verschmerzbar sein.
- Alternativ: "Tiefe Kopie" => Kann unangenehm auf die Performance und den Speicherplatz drücken
- ... (gibt noch viele andere Konzepte bis hin zu globaler "bar-Objekt-Verwaltung")

Gruß,

Simon2.

Foo::init_bar() erhält Informationen von Ausserhalb, füllt zwei Container (Member von Foo) mit diesen Informationen, und erzeugt dann Bar mit den Iteratoren der Container. Von daher war das Beispiel mit x und y etwas zu vereinfacht.
Bar ist also eine komplexe Datenstruktur aus einer fremden Lib.
Werd es dann so machen wie oben, ( "Foo(...) : bar(0), ... {...}" ) und CopyCtor und Op= verstecken, da ich eh nur ein Objekt Foo pro Anwendung erstelle.

Danke euch allen und
schöne Grüsse