virtueller Zuweisungsoperator C ++

Den Zuweisungs-operator ist nicht verpflichtet, die virtuellen.

Die Diskussion unten über operator=, aber es gilt auch zu jedem operator überladen, dass dauert in der Art in Frage, und jede Funktion, die dauert in der Art in Frage stellen.

Den unten Diskussion zeigt, dass das Schlüsselwort virtual nicht weiß, über einen parameter die erbschaft im Hinblick auf das finden einer passenden Funktion Unterschrift. In das Letzte Beispiel zeigt, wie man richtig zu behandeln Zuordnung beim Umgang mit ererbten Typen.

Virtuelle Funktionen wissen nichts über das parameter-Vererbung:

Eine Funktion ist, die Unterschrift muss identisch sein für virtuelle ins Spiel kommen. Obwohl also im folgenden Beispiel, operator= ist aus virtuellen, der Anruf wird nie handeln als virtuelle Funktion in D, da die Parameter und der Rückgabewert von operator= sind anders.

Die Funktion B::operator=(const B& right) und D::operator=(const D& right) sind zu 100% komplett anders und gesehen wie 2 verschiedene Funktionen.

class B
{
public:
  virtual B& operator=(const B& right)
  {
    x = right.x;
    return *this;
  }

  int x;

};

class D : public B
{
public:
  virtual D& operator=(const D& right)
  {
    x = right.x;
    y = right.y;
    return *this;
  }
  int y;
};

Default-Werte und mit 2 überladen von Operatoren:

Können Sie zwar definieren, die eine virtuelle Funktion, um Ihnen zu erlauben, um die Standardwerte für D, wenn es zugeordnet ist variable vom Typ B. Dies gilt auch, wenn deine variable B ist wirklich ein D gespeichert, in eine Referenz zu einem B. werden Sie nicht bekommen, die D::operator=(const D& right) Funktion.

In der unten Fall eine Zuordnung von 2-D-Objekte gespeichert, die auf der Innenseite 2 B Referenzen... die D::operator=(const B& right) überschreiben verwendet wird.

//Use same B as above

class D : public B
{
public:
  virtual D& operator=(const D& right)
  {
    x = right.x;
    y = right.y;
    return *this;
  }


  virtual B& operator=(const B& right)
  {
    x = right.x;
    y = 13;//Default value
    return *this;
  }

  int y;
};


int main(int argc, char **argv) 
{
  D d1;
  B &b1 = d1;
  d1.x = 99;
  d1.y = 100;
  printf("d1.x d1.y %i %i\n", d1.x, d1.y);

  D d2;
  B &b2 = d2;
  b2 = b1;
  printf("d2.x d2.y %i %i\n", d2.x, d2.y);
  return 0;
}

Drucke:

d1.x d1.y 99 100
d2.x d2.y 99 13

Was zeigt, dass D::operator=(const D& right) ist nie benutzt.

Ohne das Schlüsselwort virtual auf B::operator=(const B& right) Sie würden die gleichen Ergebnisse wie oben, aber der Wert von y würde nicht initialisiert werden. I. e. würde es die B::operator=(const B& right)

Einen letzten Schritt binden Sie es alle zusammen, RTTI:

Können Sie RTTI richtig zu handhaben, virtuelle Funktionen, die in Ihrem Typ. Hier ist das Letzte Stück des Puzzles, um herauszufinden, wie man richtig zu behandeln Zuordnung beim Umgang mit möglicherweise vererbten Typen.

virtual B& operator=(const B& right)
{
  const D *pD = dynamic_cast<const D*>(&right);
  if(pD)
  {
    x = pD->x;
    y = pD->y;
  }
  else
  {
    x = right.x;
    y = 13;//default value
  }

  return *this;
}

InformationsquelleAutor der Antwort Brian R. Bondy

Brian R. Bondy schrieb:

---

Einen letzten Schritt binden Sie es alle zusammen, RTTI:

Können Sie RTTI richtig zu handhaben, virtuelle Funktionen, die in Ihrem Typ. Hier ist das Letzte Stück des Puzzles, um herauszufinden, wie man richtig zu behandeln Zuordnung beim Umgang mit möglicherweise vererbten Typen.

virtual B& operator=(const B& right)
{
  const D *pD = dynamic_cast<const D*>(&right);
  if(pD)
  {
    x = pD->x;
    y = pD->y;
  }
  else
  {
    x = right.x;
    y = 13;//default value
  }

  return *this;
}

Möchte ich hinzufügen, zu dieser Lösung ein paar Bemerkungen. Mit dem Zuweisungsoperator deklariert ist die gleiche wie oben, hat drei Probleme.

Generiert der compiler eine Zuweisung ein operator ist, der nimmt ein const D& argument, das ist nicht virtuell und nicht tun, was Sie vielleicht denken, es tut.

Zweite Problem ist der return-Typ, sind Sie wieder ein Basis-Referenz auf eine abgeleitete Instanz. Wahrscheinlich nicht viel von einem Problem, wie der code funktioniert trotzdem. Noch besser ist es, die Referenzen zurückgeben entsprechend.

Dritten Ausgabe abgeleiteten Typ Zuweisungsoperator nicht nennen Basisklasse Zuweisungsoperator (was ist, wenn es private Felder, die Sie kopieren möchten?), deklarieren den Zuweisungsoperator als virtuelle nicht die compiler generieren für Sie. Dies ist eher ein Nebeneffekt, der nicht mit mindestens zwei überladungen der Zuweisungsoperator, um die erwünschten Ergebnis.

Unter Berücksichtigung der Basis-Klasse (die gleiche wie die von der post den ich zitiert):

class B
{
public:
    virtual B& operator=(const B& right)
    {
        x = right.x;
        return *this;
    }

    int x;
};

Folgende code schließt die RTTI-Lösung, die ich zitiert:

class D : public B{
public:
    //The virtual keyword is optional here because this
    //method has already been declared virtual in B class
    /* virtual */ const D& operator =(const B& b){
        //Copy fields for base class
        B::operator =(b);
        try{
            const D& d = dynamic_cast<const D&>(b);
            //Copy D fields
            y = d.y;
        }
        catch (std::bad_cast){
            //Set default values or do nothing
        }
        return *this;
    }

    //Overload the assignment operator
    //It is required to have the virtual keyword because
    //you are defining a new method. Even if other methods
    //with the same name are declared virtual it doesn't
    //make this one virtual.
    virtual const D& operator =(const D& d){
        //Copy fields from B
        B::operator =(d);
        //Copy D fields
        y = d.y;
        return *this;
    }

    int y;
};

Mag es scheinen, eine vollständige Lösung ist es nicht. Dies ist keine vollständige Lösung, weil wenn Sie die Ableitung von D benötigen Sie 1 operator = , dauert const B&, 1 operator = , dauert const D& und einem operator, der nimmt const D2&. Die Schlussfolgerung liegt auf der Hand, die Anzahl von operator = () - überladungen ist gleichbedeutend mit der Anzahl der super-Klassen + 1.

Wenn man bedenkt, dass D2 D erbt, lassen Sie uns nehmen einen Blick an, wie die beiden geerbten operator =() Methoden Aussehen.

class D2 : public D{
    /* virtual */ const D2& operator =(const B& b){
        D::operator =(b); //Maybe it's a D instance referenced by a B reference.
        try{
            const D2& d2 = dynamic_cast<const D2&>(b);
            //Copy D2 stuff
        }
        catch (std::bad_cast){
            //Set defaults or do nothing
        }
        return *this;
    }

    /* virtual */ const D2& operator =(const D& d){
        D::operator =(d);
        try{
            const D2& d2 = dynamic_cast<const D2&>(d);
            //Copy D2 stuff
        }
        catch (std::bad_cast){
            //Set defaults or do nothing
        }
        return *this;
    }
};

Es ist offensichtlich, dass die operator =(const D2&) nur Kopien Felder, stellen Sie sich vor, als ob es dort war. Wir können feststellen, ein Muster in den geerbten operator = () - überladungen. Leider können wir uns nicht definieren, virtuelle Vorlage Methoden, kümmert sich um dieses Muster, wir brauchen Sie zum kopieren und einfügen mehrere Male den gleichen code, um eine vollständige polymorphe Zuweisung-operator die einzige Lösung, die ich sehe. Gilt auch für die anderen binären Operatoren.

Bearbeiten

Wie bereits erwähnt in den Kommentaren, das Mindeste, was getan werden kann, um das Leben leichter machen, ist die Festlegung der obersten Superklasse Zuweisungs-operator =(), und rufen Sie es von allen anderen Oberklasse-operator = () - Methoden. Auch beim kopieren von Feldern eine _copy-Methode definiert werden kann.

class B{
public:
    //_copy() not required for base class
    virtual const B& operator =(const B& b){
        x = b.x;
        return *this;
    }

    int x;
};

//Copy method usage
class D1 : public B{
private:
    void _copy(const D1& d1){
        y = d1.y;
    }

public:
    /* virtual */ const D1& operator =(const B& b){
        B::operator =(b);
        try{
            _copy(dynamic_cast<const D1&>(b));
        }
        catch (std::bad_cast){
            //Set defaults or do nothing.
        }
        return *this;
    }

    virtual const D1& operator =(const D1& d1){
        B::operator =(d1);
        _copy(d1);
        return *this;
    }

    int y;
};

class D2 : public D1{
private:
    void _copy(const D2& d2){
        z = d2.z;
    }

public:
    //Top-most superclass operator = definition
    /* virtual */ const D2& operator =(const B& b){
        D1::operator =(b);
        try{
            _copy(dynamic_cast<const D2&>(b));
        }
        catch (std::bad_cast){
            //Set defaults or do nothing
        }
        return *this;
    }

    //Same body for other superclass arguments
    /* virtual */ const D2& operator =(const D1& d1){
        //Conversion to superclass reference
        //should not throw exception.
        //Call base operator() overload.
        return D2::operator =(dynamic_cast<const B&>(d1));
    }

    //The current class operator =()
    virtual const D2& operator =(const D2& d2){
        D1::operator =(d2);
        _copy(d2);
        return *this;
    }

    int z;
};

Gibt es keine Notwendigkeit für eine set defaults Methode, denn Sie würde erhalten, nur einen Anruf (in der Basis-operator =() überladen). Änderungen beim kopieren von Feldern sind an einem Ort durchgeführt werden und alle operator = () - überladungen sind betroffen und tragen den beabsichtigten Zweck.

Dank sehe für die Anregung.

InformationsquelleAutor der Antwort Andrei15193

Es ist nur erforderlich, wenn Sie sicherstellen wollen, dass Klassen, die von Ihrer Klasse bekommen alle Ihre Mitglieder korrekt kopiert. Wenn Sie nicht tun, alles, was mit Polymorphismus, dann müssen Sie nicht wirklich brauchen, zu kümmern.

Ich kenne nichts, dass würde verhindern, dass Sie durch die Virtualisierung jeder operator, den Sie wollen-Sie sind nichts als der Besondere Fall-Methode aufruft.

Auf dieser Seite bietet eine sehr gute und ausführliche Beschreibung, wie dies alles funktioniert.

InformationsquelleAutor der Antwort sblom