HasPtr& HasPtr::operator=(const HasPtr &rhs)
{
  ++rhs.ptr->use;
  if(--ptr->use == 0) delete ptr;  //was soll diese Abfrage? Schritt 1 schließt doch hier das true aus?
  ptr = rhs.ptr;
  val = rhs.val;
  return *this:
}

hier noch die dazu gehörenden Klassen:

class HasPtr
{
  public:
  HasPtr(int* p, int i): ptr(new U_Ptr(o)), val(i) {}
  HasPtr(const HasPtr &orig): ptr(orig.ptr), val(orig.val) {++ptr->use;}
  HasPtr& operator=(const HasPtr&);
  ~HasPtr() { if (--ptr->use == 0) delete ptr;}
  pirvate:
  U_ptr *ptr;
  int val;
};

class U_Ptr
{
  friend class HasPtr;
  int *p;
  size_z use;
  U_Ptr(int *p): ip(p), use(1) {};
  ~U_Ptr() {}
};

wär schön wenn mir das jemand erklären könnte, bzw n besipiel geben könnte wo diese Bedingung true ergibt und der ptr gelöscht würde.

lg S.

das das so rum geschrieben ist, hat den grund, dass sonst selbstzuweisung nicht funktionieren würde...
(andersrum wär es vrmtl intuitiver)

bb

Bei einer Selbstzuweisung wird zuerst rhs.ptr inkrementiert. rhs.ptr entspricht hierbei aber this.ptr (oder einfach ptr). In der folgenden if-Abfrage wird ptr dektrementiert, sodass am Ende gar nichts passiert ist.

bnz

A = B;

                         Counter A                 Counter B
Start                       1                         3
++rhs.ptr->use;             1                         4
if(--ptr->use == 0)         0                         4
 -> delete von ptr in A.
ptr = rhs.ptr;              4                         4

Selbstzuweisung:

A = A;

                         Counter A                 Counter A
Start                       1                         1
++rhs.ptr->use;             2                         2
if(--ptr->use == 0)         1                         1
 -> Kein delete.
ptr = rhs.ptr;              1                         1

Wenn bei der Selbstzuweisung zuerst die Überprüfung kommen würde:

A = A;

                         Counter A                 Counter A
Start                       1                         1
if(--ptr->use == 0)         0                         0
 -> delete von ptr in A.
++rhs.ptr->use;             CRASH; BUMM; PATAMM; BENG

Grüssli

jo, zu dem Schluss bin ich auch gekommen^^, nur ich habe mich gefragt wieso zwei sinnloszeilen schreiben? Da muss doch ein tieferer Sinn liegen.

Sinnlos? Wieso sollen die sinnlos sein? Die beziehen sind auf unterschiedliche Objekte!

Grüssli

noch ne Frage zum Thema:

dieser ganze Code wurde ja geschrieben damit das kein crash ergibt:

int* ip = new int(42);

HasPtr ptr(ip,10);

delete ip;

ptr.set_ptr_val(0);

aber das problem besteht doch immernoch?
Wenn der Benutzer es lustig findet ip zu deleten wird doch auch der new int gelöscht oder? Oder ist das hier so wie bei Java das solange eine Referenz (in dem Falle Pointer) auf das Objekt verweist lebt es?

HasPtr foo(new int(42));

foo.set_val(14);

bb