Was ist Objekt-Slicing?

Jemand erwähnte es im IRC als das Slicing-Problem.

„Slicing“ bedeutet, dass Sie ein Objekt einer abgeleiteten Klasse einer Instanz einer Basisklasse zuweisen und dabei einen Teil der Informationen verlieren – einige davon werden „weggeschnitten“.

Zum Beispiel,

class A {
   int foo;
};

class B : public A {
   int bar;
};

Also ein Objekt vom Typ B hat zwei Datenmitglieder, foo und bar.

Wenn du dann das schreiben würdest:

B b;

A a = b;

Dann die Informationen rein b über Mitglied bar ist darin verloren a.

Die meisten Antworten hier erklären nicht, was das eigentliche Problem beim Slicing ist. Sie erklären nur die gutartigen Fälle des Schneidens, nicht die tückischen. Gehen Sie wie bei den anderen Antworten davon aus, dass Sie es mit zwei Klassen zu tun haben A und Bwo B leitet sich (öffentlich) ab A.

In dieser Situation lässt C++ Sie eine Instanz von übergeben B zu A‘s Zuweisungsoperator (und auch an den Kopierkonstruktor). Dies funktioniert, weil eine Instanz von B kann in ein umgewandelt werden const A&was Zuweisungsoperatoren und Kopierkonstruktoren von ihren Argumenten erwarten.

Der gutartige Fall

B b;
A a = b;

Da passiert nichts Schlimmes – Sie haben nach einer Instanz von gefragt A das ist eine Kopie von B, und genau das bekommen Sie. Sicher, a enthält nicht einige von b‘s Mitglieder, aber wie sollte es? Es ist ein Aschließlich nicht a Balso hat es nicht einmal gehört über diese Mitglieder, geschweige denn in der Lage wäre, sie zu speichern.

Der heimtückische Fall

B b1;
B b2;
A& a_ref = b2;
a_ref = b1;
//b2 now contains a mixture of b1 and b2!

Das denken Sie vielleicht b2 wird eine Kopie von sein b1 nachher. Aber leider ist es so nicht! Wenn Sie es untersuchen, werden Sie das feststellen b2 ist eine Frankensteinsche Kreatur, die aus einigen Brocken hergestellt wurde b1 (die Stücke, die B erbt von A) und einige Stücke von b2 (die Stücke, die nur B enthält). Autsch!

Was ist passiert? Nun, C++ behandelt Zuweisungsoperatoren standardmäßig nicht als virtual. Also die Linie a_ref = b1 wird den Zuweisungsoperator von anrufen Anicht das von B. Dies liegt daran, dass für nicht virtuelle Funktionen die erklärt (formal: statisch) Typ (das ist A&) bestimmt, welche Funktion aufgerufen wird, im Gegensatz zu der tatsächlich (formal: dynamisch) Typ (was wäre Bseit a_ref verweist auf eine Instanz von B). Jetzt, ADer Zuweisungsoperator von kennt offensichtlich nur die in deklarierten Mitglieder Asodass nur diese kopiert werden und die Mitglieder hinzugefügt bleiben B unverändert.

Eine Lösung

Die Zuweisung nur an Teile eines Objekts macht normalerweise wenig Sinn, aber C++ bietet leider keine eingebaute Möglichkeit, dies zu verbieten. Du kannst aber auch selbst rollen. Der erste Schritt besteht darin, den Zuweisungsoperator zu erstellen virtuell. Dadurch wird garantiert, dass es immer der tatsächlich Zuweisungsoperator des Typs, der aufgerufen wird, nicht der erklärt Art. Der zweite Schritt ist die Verwendung dynamic_cast um zu überprüfen, ob das zugewiesene Objekt einen kompatiblen Typ hat. Der dritte Schritt besteht darin, die eigentliche Zuweisung in einem (geschützten!) Mitglied vorzunehmen assign()seit B‘S assign() werde wahrscheinlich verwenden wollen A‘S assign() Kopieren As, Mitglieder.

class A {
public:
  virtual A& operator= (const A& a) {
    assign(a);
    return *this;
  }

protected:
  void assign(const A& a) {
    // copy members of A from a to this
  }
};

class B : public A {
public:
  virtual B& operator= (const A& a) {
    if (const B* b = dynamic_cast<const B*>(&a))
      assign(*b);
    else
      throw bad_assignment();
    return *this;
  }

protected:
  void assign(const B& b) {
    A::assign(b); // Let A's assign() copy members of A from b to this
    // copy members of B from b to this
  }
};

Beachten Sie, dass aus reiner Bequemlichkeit B‘S operator= überschreibt den Rückgabetyp kovariant, da er weiß dass es eine Instanz von zurückgibt B.

Wenn Sie eine Basisklasse haben A und eine abgeleitete Klasse Bdann können Sie Folgendes tun.

void wantAnA(A myA)
{
   // work with myA
}

B derived;
// work with the object "derived"
wantAnA(derived);

Jetzt die Methode wantAnA benötigt eine Kopie von derived. Allerdings das Objekt derived kann nicht vollständig kopiert werden, da die Klasse B könnte zusätzliche Mitgliedsvariablen erfinden, die nicht in seiner Basisklasse enthalten sind A.

Daher anrufen wantAnA, wird der Compiler alle zusätzlichen Member der abgeleiteten Klasse “abtrennen”. Das Ergebnis könnte ein Objekt sein, das Sie nicht erstellen wollten, weil

• es kann unvollständig sein,
• es verhält sich wie ein A-Objekt (alle speziellen Verhaltensweisen der Klasse B ist verloren).

Das sind alles gute Antworten. Ich möchte nur ein Ausführungsbeispiel hinzufügen, wenn Objekte als Wert oder als Referenz übergeben werden:

#include <iostream>

using namespace std;

// Base class
class A {
public:
    A() {}
    A(const A& a) {
        cout << "'A' copy constructor" << endl;
    }
    virtual void run() const { cout << "I am an 'A'" << endl; }
};

// Derived class
class B: public A {
public:
    B():A() {}
    B(const B& a):A(a) {
        cout << "'B' copy constructor" << endl;
    }
    virtual void run() const { cout << "I am a 'B'" << endl; }
};

void g(const A & a) {
    a.run();
}

void h(const A a) {
    a.run();
}

int main() {
    cout << "Call by reference" << endl;
    g(B());
    cout << endl << "Call by copy" << endl;
    h(B());
}

Die Ausgabe ist:

Call by reference
I am a 'B'

Call by copy
'A' copy constructor
I am an 'A'

Dritte Übereinstimmung in Google für “C++ Slicing” gibt mir diesen Wikipedia-Artikel http://en.wikipedia.org/wiki/Object_slicing und dies (erhitzt, aber die ersten Posts definieren das Problem): http://bytes.com/forum/thread163565.html

Also, wenn Sie der Superklasse ein Objekt einer Unterklasse zuweisen. Die Oberklasse weiß nichts von den zusätzlichen Informationen in der Unterklasse und hat keinen Platz, um sie zu speichern, sodass die zusätzlichen Informationen “abgeschnitten” werden.

Wenn diese Links nicht genügend Informationen für eine “gute Antwort” liefern, bearbeiten Sie bitte Ihre Frage, um uns mitzuteilen, wonach Sie noch suchen.

Das Slicing-Problem ist schwerwiegend, da es zu einer Speicherbeschädigung führen kann, und es ist sehr schwierig zu garantieren, dass ein Programm nicht darunter leidet. Um es außerhalb der Sprache zu entwerfen, sollten Klassen, die die Vererbung unterstützen, nur über Verweis (nicht über Wert) zugänglich sein. Die Programmiersprache D hat diese Eigenschaft.

Betrachten Sie Klasse A und Klasse B, die von A abgeleitet ist. Speicherbeschädigung kann auftreten, wenn der A-Teil einen Zeiger p und eine B-Instanz hat, die p auf die zusätzlichen Daten von B zeigt. Wenn dann die zusätzlichen Daten abgeschnitten werden, zeigt p auf Müll.

In C++ kann ein abgeleitetes Klassenobjekt einem Basisklassenobjekt zugewiesen werden, aber der umgekehrte Weg ist nicht möglich.

class Base { int x, y; };

class Derived : public Base { int z, w; };

int main() 
{
    Derived d;
    Base b = d; // Object Slicing,  z and w of d are sliced off
}

Objekt-Slicing findet statt, wenn ein abgeleitetes Klassenobjekt einem Basisklassenobjekt zugewiesen wird, zusätzliche Attribute eines abgeleiteten Klassenobjekts werden abgeschnitten, um das Basisklassenobjekt zu bilden.