operatoren erben

Pigeon

Hallo .... ich bin am verzweifeln!
Warum, WARUM geht das nicht?

class base
{
public:
	int DATA;

	base& operator=(base o) { DATA = o.DATA; }
	base  operator+(base& o) { base ret; ret.DATA + o.DATA; return ret; }
};

class deri : public base
{
public:
	deri() {}
};

int main()
{
	deri a;
	deri b; b.DATA = 1;
	deri c; c.DATA = 2;

	a = b + c;
}

GCC 4.1.2 schrieb:

test.cpp: In function »int main()«:
test.cpp:63: Fehler: no match für »operator=« in »a = b.deri::<anonymous>.base::operator+(((base&)(& c.deri::<anonymous>)))«
test.cpp:52: Anmerkung: Kandidaten sind: deri& deri::operator=(deri&)

Dankeschön

Pigeon

using base::operator=; in deri reinschreiben.

Danke!

Aber warum???

Pigeon

Lol ... der Thread wird irgendwie überflüssig ^^

"Weil Zuweisungsoperatoren genauso wenig wie Konstruktoren vererbt werden!"

Aha, ok. Danke

drakon

- Selbstgespräche sind manchmal auch schön.

queer_boy

dass sie nicht vererbt werden, ist nicht ganz richtig.
der compiler erzeugt aber für jede klasse automatisch einen zuweisungsoperator. stell dir einmal statt dem zuweisungsoperator eine andere funktion vor:

struct Base
{
   void foo () { }
};

struct Derived : Base
{
   void foo (int) {}
};

nun erzeug malein objekt vom typ Derived, und versuche, darüber Base::foo aufzurufen:

Derived d;
d.foo();

das wird nicht funktionieren. und warum nicht? weil die funktion foo(int) in Derived foo() aus Base verdeckt.
zugriff auf Base::foo hast du noch entweder so:

d.Base::foo();

oder indem du in der klasse Derived selbst sagst, dass du die funktionen aus Base weiterverwenden willst:

struct Derived: Base
{
   using Base::foo;
   void foo (int) {}
};

so. nun passiert dasselbe aber mit deiner klasse deri, in der der vom compiler generierte zuweisungsoperator alle zuweisungsoperatoren der basisklasse verdeckt. anschaulich kannst du es dir so vorstellen:

deri a, b, c;
c.operator= (a + b);
//a + b liefert ein base, deri::operator=(base) ist aber von 
//deri::operator=(deri const&) verdeckt. es gibt keine
//implizite konvertierung von base nach deri. lösung:

c.base::operator= (a + b);
//oder eben die variante mit using.

queer_boy

noch ein nachtrag: zuweisungsoperatoren können sehr wohl vererbt werden. auch virtuelle zuweisungsoperatoren sind möglich.

Simon2

Hi,

kein Widerspruch, sondern nur eine Ergänzung:

queer_boy schrieb:

noch ein nachtrag: zuweisungsoperatoren können sehr wohl vererbt werden. auch virtuelle zuweisungsoperatoren sind möglich.

Damit sind sie in der abgeleiteten Klasse sichtbar ... allerdings kann man dann trotzdem "Match-Probleme" bekommen (weil der Operator ja kein "derived object" als Parameter entgegennehmen kann).

Gruß,

Simon2.