hab einen Beleg zu machen und komm an einer Stelle nicht weiter. Folgendes Problem:

Ich will in einer Klasse einen Zuweisungsoperator überladen.

person operator=(person &p)

allerdings ist das this 0.

nun komme ich in schwierigkeiten, wenn ich die member von p auf this zuweisen will. (2 mal char, 1 char-vektor und 1 unsigned int)

wäre schön, wenn jemand helfen könnte.

mfg

fife

person &operator=(person &p){
      if((this != &p) && (&p) ){
	this->setname(p.getname());
	this->setvorname(p.getvorname());
	this->at=p.getat();
	if(this->at){
	     tel = new char *[at];
              for(unsigned int i=0; i<at; i++){
                 tel[i] = new char[strlen(p[i])+1];
                 strcpy(tel[i], p[i]);
              }
         }
         return *this;
       }
       else if( (this == &p) && (&p))
 	return *this;
       else if( (this != &p) && !(&p)){
	setname("unbekannt");
	setvorname("unbekannt");
	at=0;
	tel=0;
	return *this;
       }
       else if( (!this) && !(&p)){
	// ToDo !!! Zuweisung an 0-Objekt
	return *this;
       }
}

Es geht um den letzten else if-Zweig:

in der main steht da:

*p1 = *p2;

wobei *p2 ein Objekt ist, was mit new angelegt wurde.
Nur *p1 existiert noch nicht.

genau da liegt das problem, wie ich dem *p1, welches inner klasse das this is, was zuweisen kann.

mfg fife

if([...] && (&p)

Nur *p1 existiert noch nicht.

Wtf? Es gibt keine "0-Objekte". Entweder es gibt das Objekt, oder nicht!

MfG

GPC

*p1 = *p2;

wobei *p2 ein Objekt ist, was mit new angelegt wurde.
Nur *p1 existiert noch nicht.

Dann kannst du *p1 auch nichts zuweisen. Zuweisungen ändern immer existierende Objekte.

Vielleicht willst du p1 was zuweisen. Entweder p1 auch auf *p2 zeigen lassen:

p1=p2;

Oder p1 auf eine Kopie von *p2 zeigen lassen:

p1 = new person(*p2);

das ist die originale vorgegebene main().
und wie man sieht wird in zeile 13 *p1 gelöscht, allerdings soll in zeile 19 diesem 'gelöschten' objekt was zugewiesen werden.

hoffe der zusammenhang ist deutlicher geworden.
(wer meint, daß das nicht geht kann gern die mail-addy vom prof. haben )

Aber vielleicht wollte Euer Prof ja auch dass ihr genau das rausfindet?

GPC schrieb:

Referenzen können nicht auf null getestet werden, deshalb ist diese Bedingung auch ziemlich schwachsinnig:

if([...] && (&p)

^^ war für den fall gedacht, daß ein 0-objekt übergeben wird. funktioniert allerdings.

Kein Schreibfehler... wahrscheinlich isses doch Heimtücke.

GPC schrieb:

Referenzen können nicht auf null getestet werden, deshalb ist diese Bedingung auch ziemlich schwachsinnig:

if([...] && (&p)

^^ war für den fall gedacht, daß ein 0-objekt übergeben wird. funktioniert allerdings.

wie bereits erwähnt: es gibt keine 0-objekte, this ist niemals 0 - und der aufruf einer member funktion über einen 0-pointer bzw. das dereferenzieren eines null-pointers ist stets undefiniertes verhalten völlig unabhängig davon, ob das ganze unter bestimmten bedingungen mit einem bestimmten compiler "funktioniert", d.h. ein wohlbestimmtes ergebnis erzeugt.

wie bereits erwähnt: es gibt keine 0-objekte, this ist niemals 0

Das kann schonmal passieren, dann ist es aber ein Programmierfehler:

struct Foo {
    void bar() { cout << hex << "0x" << this; }
};

int main() 
{
    Foo* fooptr = 0;
    fooptr->bar(); // kann problemlos funktionieren
}

camper schrieb:

wie bereits erwähnt: es gibt keine 0-objekte, this ist niemals 0

Das kann schonmal passieren, dann ist es aber ein Programmierfehler:

was ich im weiteren text, den du versäumt hast, zu zitieren, bereits erläuterte. und der begriff des 'programmierfehlers' ist eher ungeeignet, das verhalten von programmen zu beschreiben. eine aussage - es gibt keine 0-objekte etc. - ist ohnehin nur im kontext wohldefinierten verhaltens zu verstehen. ich denke nicht, dass es notwendig ist, das jedesmal zu betonen.

ich bin auch schon mit code, der ganz bewusst mit this==0 operiert, zu tun gehabt - ich kann nur sagen: gruselig. selbst wenn es zulässig wäre (und nur der zugriff auf member variablen verboten) wäre es doch extrem schwierig, das ganze richtig hinzubekommen.