Zuweisung an 0

Hallo,

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

ser1al

zeig doch mal bisschen code, wo dein problem dargestellt wird

Die Operator-Methode ist Bestandteil der Klasse person

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

GPC

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

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

Nur *p1 existiert noch nicht.

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

MfG

GPC

Bashar

fife2 schrieb:

*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);

void main(){
   person *p0 = new person(); //Defaultkonstruktor
   cout<<*p0; delete p0; p0 = 0;

   p0 = new person("Mueller","Bernd"); //Konstruktor, 2 Parameter
   cout<<"*p0 = "<<*p0; delete p0; p0 = 0;

   p0 = new person("Neumann","Alex","460 2440"); //Konstruktor, 3 Parameter
   cout<<"*p0 = "<<*p0;

   person *pp0 = 0;
   person *p1 = new person(*pp0); //Kopierkonstruktor (pp0==0)
/*13*/   cout<<"*p1 = "<<*p1; delete p1; p1 = 0;

   person *p2 = new person(*p0); //Kopierkonstruktor (*p0)
   cout<<"*p2 = "<<*p2;
   *p2 = *p1; //Zuweisungsoperator *p2:=0
   cout<<"*p2 = "<<*p2; delete p2; p2 = 0;
/*19*/   *p1 = *p2; //Zuweisungsoperator 0:=0
   cout<<"*p1 = "<<*p1;

   *p1 = *p0; //Zuweisungsoperator 0:=*p0
   cout<<"*p1 = "<<*p1; delete p1; p1 = 0;
...
}

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 )

LordJaxom

Tja, leider ist *p1 ab Zeile 13 undefiniert (da p1 auf kein Objekt zeigt) und damit ist auch jede Benutzung von *p1 (spätestens in Zeile 17) undefiniert, bevor nicht p1 etwas neues zugewiesen wurde.

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

In Zeile 19 als auch schon in Zeile 17 dereferenzierst du einen NULL-Pointer.
Das geht definitiv schief, und ist daher:
- ein Schreibfehler (deinerseits)
- ein Verständnisfehler (deines Profs)
- Heimtücke (deines Profs)

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.

camper

fife2 schrieb:

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.

FireFlow

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:

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

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

camper

FireFlow schrieb:

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.