class Array
{
    public:
    virtual Array& operator = ( const Array& a ) = 0;
    virtual bool   operator ==( const Array& a ) = 0;
};

class PolymArray : public Array
{
    public:
    Array& operator = ( const Array& a ) { return *this; }
    bool   operator ==( const Array& a ) { return  true; }
};

int main()
{
    PolymArray a;
    PolymArray b;
    a==b;   // Kein Problem.
    a=b;     // Ein Problem!
    return 0;
}

Was mache ich falsch?

class PolymArray : public Array
{
    public:
    PolymArray& operator = ( const PolymArray& a ) { return *this; }
    bool   operator ==( const Array& a ) { return  true; }
};

Ist das nicht einfach nur eine Überladung statt Polymorphie?
Mal ganz nebenbei täte mich auch interessieren, warum es bei == geht und bei = nicht.

||=== Testprogramm, Debug ===|
In function int main()': error: cannot declare variable \a' to be of type `PolymArray'
error: because the following virtual functions are abstract:
error: virtual Array& Array::operator=(const Array&)
error: cannot declare variable `b' to be of type `PolymArray'
error: since type `PolymArray' has abstract virtual functions

Gibt es noch weitere Ideen?

//so (diese Variante ist zu bevorzugen):
class Array
{
    public:
    virtual Array& operator = ( const Array& a ) = 0 { return *this; }
    virtual bool   operator ==( const Array& a ) = 0;
};
//oder so:
class Array
{
    public:
    virtual Array& operator = ( const Array& a ){ return *this; }
    virtual bool   operator ==( const Array& a ) = 0;
};

Der Aufruf von operator ruft alle operator= -Funktionen seiner Elternklassen auf.

Nur wenn er automatisch generiert wird. Bei selbstgeschriebenen op= muss man das falls benötigt selber machen.

Ich persöhnlich frage mich allerdings was ein polymorpher op= bewerkstelligen soll. Folgendes wäre z.B. sinnfrei:

class Fahrzeug;
class Auto : public Fahrzeug {/*...*/}
class Zweirad : public Fahrzeug {/*...*/}

//...

karre = mopped; //????

Tachyon schrieb:

Der Aufruf von operator ruft alle operator= -Funktionen seiner Elternklassen auf.

Nur wenn er automatisch generiert wird. Bei selbstgeschriebenen op= muss man das falls benötigt selber machen.

Jap. Für PolymArray wird auch automatisch ein Default- operator=() generiert. Nämlich PolymArray & operator=(PolymArray const &) . Und dieser versucht, den operator= von Array aufzurufen, was folgerichtig zu einer undefinierten Referenz führt.
Erzwingt man die Benutzung des korrekten Operatos mit a = static_cast<Array&>(b) , dann funktioniert es wie erwartet.
Das gleiche hast Du auch beim nicht-virtuellen operator= :

#include <iostream>

struct test
{
    test& operator=(char c){ std::cout << "char\n"; return *this; }
};

int main()
{
    test a;
    test b;

    a = 'c'; //ruft test& operator=(char c) auf

    b = a; //ruft default operator=() auf
}

PS: Du hast aber damit recht, dass der rein virtuelle Zuweiser wenig Sinn macht. In den seltensten Fällen tut er das, was man will.

PS: Du hast aber damit recht, dass der rein virtuelle Zuweiser wenig Sinn macht. In den seltensten Fällen tut er das, was man will.

Das gilt aber auch für operator== .

Wenn man wirklich Objekte unterschiedlichen Typs vergleichen möchte (was ich an sich schon fragwürdig finde), wäre vielleicht etwas über dynamic_cast möglich. Damit mindestens false zurückgegeben werden kann, wenn die dynamischen Typen unterschiedlich sind.

Das Problem bei virtuellen Funktionen ist auch die Asymmetrie; a == b kann unter Umständen etwas anderes bewirken als b == a .

Was ich mit einem abstrakten Zuweisungsoperator mache, kann ich euch gern sagen: Es handelt sich um eine abstrakte Basisklasse, die ihrerseits noch keine Elementdaten besitzt. Eine abstrakte Zuweisung ist da denkbar... zumindest jedoch nicht unsinnig.

Was ich mit einem abstrakten Zuweisungsoperator mache, kann ich euch gern sagen: Es handelt sich um eine abstrakte Basisklasse, die ihrerseits noch keine Elementdaten besitzt. Eine abstrakte Zuweisung ist da denkbar... zumindest jedoch nicht unsinnig.

Kannst Du mal ein Beispiel nennen, wieso das sinnvoll sein soll?

Kannst Du mal ein Beispiel nennen, wieso das sinnvoll sein soll?

damit kann ich endlich typen ändern. schau:

Sparkonto k1;
Girokonto k2;
k2=k1;//wird automagisch zum Sparkonto

Tachyon schrieb:

Kannst Du mal ein Beispiel nennen, wieso das sinnvoll sein soll?

damit kann ich endlich typen ändern. schau:

Sparkonto k1;
Girokonto k2;
k2=k1;//wird automagisch zum Sparkonto

schau:

Nettes Beispiel.