3. Frage zu new und delete

Frage zu new und delete

  • R

    Hallo,

    generell muss man doch Speicherplatz von Instanzen, die mit new angelegt wurden, mit delete freigeben.

    Meine Frage ist jetzt, wie das ist, wenn man nicht weiss, ob mit new angelegt wurde (z. B. wenn man im folgenden Fall die Implementierung von Klasse& Klasse::Copy () nicht kennt).

    class Klasse
{
  ...
  Klasse& Copy ()
  {
    Test* result = new Klasse (*this);
    return result;
  }
};

    muss ich im folgenden Fall dann obj2 mit delete loeschen, oder wird der Destruktor automatisch aufgerufen:

    int main ()
{
  if (...)
  {
    Klasse obj1;
    Klasse obj2 = obj1.copy ();
  }

  ...
}

    Danke und mfg
    rodo

    0
  • S

    Das ist ein Design Fehler.

    Du machst kein copy() oder clone() in C++ - in C++ hat man dafür den CopyConstructor.

    Generell sollte aber jede Funktion die Speicher dynamisch allokiert entweder ein passendes deallokieren anbieten oder aber einen smart pointer liefern

    0
  • R

    Hi,

    danke fuer deine schnelle Antwort.

    Das mit dem Copy war jetzt eigentlich nur ein Beispiel - mir gings darum, ob in diesem Fall der Speicher von obj2 am Ende der if-Schleife automatisch freigegeben wird.

    Falls nicht, was ist ein smart pointer?

    Danke nochmal und mfg
    rodo

    0
  • ?

    Es wurde schon gesagt. Wenn in einer Klasse zb. Speicher mit new allokiert wird dann muß dieser auch von der Klasse wieder frei gegeben werden. Das kann man im Destruktor machen. So muß derjenige der die Klasse benutzt sich nicht darum kümmern, selbst wenn er die Implementation kennt. Das ist aber die Aufgabe desjenigen der die Klasse erstellt und NICHT von dem der die Klasse benutzt.

    0
  • ?

    Shade Of Mine schrieb:

    Du machst kein copy() oder clone() in C++ - in C++ hat man dafür den CopyConstructor.

    Da bin aber mal gespannt wie du folgendes Problem ohne clone() in C++ lösen willst

    class Base
{
public:
  virtual Base*clone()const=0;
};
class Derived:public Base
{
public:
  Derived*clone()const{return new Derived;}
};
void foo(const Base*base)
{
  Base*copied = base->clone();
}
    0
  • M

    lol

    0
  • S

    Irgendwer schrieb:

    Da bin aber mal gespannt wie du folgendes Problem ohne clone() in C++ lösen willst

    Es ging aber um das Kopieren eines Objektes by value.

    tja, nice try, aber themen verfehlung.

    0
  • G

    rodo schrieb:

    mir gings darum, ob in diesem Fall der Speicher von obj2 am Ende der if-Schleife automatisch freigegeben wird.

    Wie schon mehrfach angedeutet, nein.

    rodo schrieb:

    Falls nicht, was ist ein smart pointer?

    Ein Zeiger, der sich um das Freigeben des Speichers selbst kümmert.
    Bsp

    smart_ptr<Klasse> clone() const
{
    return smart_ptr<Klasse>(new Klasse(*this));
}

    Normalerweise müsste sich der Aufrufer selbst um das Freigeben des Speichers kümmern. Dank des Smart-Pointers wird ihm diese Arbeit aber abgenommen.

    0
  • N

    Und ein smart_ptr könnte (ansatzweise) so aussehen:

    template<class T>
class smart_ptr
{
private:
    T* d;
public:
    smart_ptr(T* pt):d(pt){};
    smart_ptr():d(0){};
    smart_ptr(const smart_ptr& o)    //Was jetzt? Am besten ein policy. Möglichkeiten:
        //:d(new T(*o.d){};               //probleme bei polymorphie
        //:d(o->clone()){};                //Probleme bei anderem Methodennnamen
        //:d(clone<T>::do_clone(o.d)){} //musst eine neue policy template<class>class clone in die templateparameterliste schreiben, könnte etwa so aussehen:
            //template<class T>struct m_clone{static T* do_clone(T* p)
            //    {/*deine_clone_methode_aufrufen*/};};
    T* operator->(){/*assert(d)*/return d;};    //Möglichkeit zur Fehlerprüfung
    T& operator*(){/*assert(d);*/return d;};    //dito
};

    Hab jetzt aber nicht const bedacht, dazu schwirrt mir grad folgendes im Kopf herum:

    template<class T>
struct is_const
{
    enum{is=false};
};
template<class T>
struct is_const<const T>
{
    enum{is=true};
};

class const_smart_pointer
{
    //...
};

class non_const_smart_pointer
{
    //...
};

template<bool>
struct help
{
    typedef const_smart_pointer type;
};

template<>
struct help<false>
{
    typedef non_const_smart_pointer type;
};

class smart_pointer
    :public typename help<is_const<typeof(this)>::is>::type
{
    //...
};

    Kann das gehen? Ich meine, der compiler müsste ja ein und die selbe Klasse mit verschiedener Funktionalität generieren. Ich weiß das typeof nicht standard ist, aber was machen Kompiler, die das unterstützen, daraus?

    0
Anmelden zum Antworten