Was ist object slicing?

Meisten Antworten hier ausfallen zu erklären was das eigentliche problem mit dem schneiden ist. Sie erklären den gutartigen Fällen von schneiden, nicht von der tückischen lieben. Davon aus, wie die anderen Antworten auch, dass man es mit zwei Klassen A und B, wo B leitet (öffentlich) aus A.

In dieser situation, In C++ können Sie übergeben Sie eine Instanz von B zu A's Zuweisungsoperator und der copy-Konstruktor). Dies funktioniert, da eine Instanz von B umgewandelt werden können, um eine const A&, was Operatoren und copy-Konstruktoren erwarten, dass Ihre Argumente zu sein.

Den gutartigen Fall

B b;
A a = b;

Nichts schlimmes passiert es - Sie fragte, für eine Instanz von A das eine Kopie von B, und das ist genau das, was Sie bekommen. Sicher, a nicht enthalten einige der b's Mitglieder, aber wie sollte es auch? Es ist ein A, nachdem alle, nicht ein B, also es hat noch nicht einmal gehört über diese Mitglieder, geschweige denn, Sie würde in der Lage sein, um Sie zu speichern.

Die tückischen Falle

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

Könnte man denken, dass b2 wird eine Kopie der b1 danach. Aber, ach, es ist nicht! Wenn Sie untersuchen, werden Sie feststellen, dass b2 ist ein Frankensteinian Kreatur, aus einige Stücke von b1 (die Brocken, die B erbt von A), und einige Stücke von b2 (die Brocken, die nur B enthält). AUA!

Was ist passiert? Gut, C++ standardmäßig nicht behandeln Zuweisungsoperatoren als virtual. So, die Zeile a_ref = b1 ruft den Zuweisungsoperator der A nicht, dass der B. Dies ist, weil für nicht-virtuelle Funktionen, die erklärt Typ (der A&) legt fest, welche Funktion aufgerufen wird, im Gegensatz zu den tatsächlichen geben (das wäre B, da a_ref referenziert eine Instanz von B). Jetzt A's Zuweisungsoperator weiß offensichtlich nur über die Mitglieder erklärten in A, so wird es kopiert nur die, verlassen die Mitglieder Hinzugefügt B unverändert.

Lösung

Zuweisung nur auf Teile eines Objekts in der Regel wenig Sinn macht, aber C++ leider bietet keine integrierte Möglichkeit, dies verbieten. Sie können jedoch Rollen Sie Ihre eigenen. Der erste Schritt ist die Herstellung der Zuweisungsoperator virtuellen. Dies wird garantieren, dass es immer die tatsächlichen Typ ist ein Zuweisungsoperator, das heißt, nicht die erklärt geben. Der zweite Schritt ist die Verwendung dynamic_cast um zu überprüfen, dass das zugewiesene Objekt hat einen kompatiblen Typ. Der Dritte Schritt ist, um die tatsächliche Zuordnung in eine (geschützte!) Mitglied assign(), da B's assign() vielleicht A's assign() kopieren A's 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 für Reine Bequemlichkeit, B's operator= covariantly überschreibt die zurück geben, da es weiß, dass es die Rückgabe einer Instanz von B.

InformationsquelleAutor fgp

Diese sind alle gute Antworten. Ich möchte nur hinzufügen, eine Ausführung Beispiel bei der übergabe von Objekten per value vs Verweis:

#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());
}

Ausgabe:

Call by reference
I am a 'B'

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

InformationsquelleAutor geh

Dem slicing-problem ist ernst, denn es kann zu einer Speicherbeschädigung führen, und es ist sehr schwierig zu garantieren, ein Programm nicht darunter leiden. Das design aus der Sprache, Klassen, Vererbung zugänglich sein sollen nur als Referenz (nicht als Wert). Die D-Programmiersprache besitzt diese Eigenschaft.

Überlegen, Klasse A, und Klasse B, abgeleitet von A. Speicher Korruption kann passieren, wenn der Eine Teil hat einen Zeiger p und eine B-Instanz, die Punkte p zu B zusätzliche Daten. Dann, wenn die zusätzlichen Daten wird abgeschnitten, p verweist Müll.

InformationsquelleAutor Walter Bright

Also ... Warum verliert der abgeleitete Informationen schlecht? ... weil der Autor der abgeleiteten Klasse kann verändert die Darstellung so, dass Sie schneiden Sie die zusätzlichen Informationen, ändert sich der Wert, repräsentiert durch das Objekt. Dies kann passieren, wenn die abgeleitete Klasse, wenn verwendet, um cache-Darstellung, die effizienter ist für bestimmte Operationen, aber teuer zu transformieren zurück an die Basis-Darstellung.

Dachte auch, jemand sollte auch erwähnen, was Sie tun sollten, um zu vermeiden, schneiden...
Holen Sie sich eine Kopie von C++ Coding Standards, 101 Regeln, Richtlinien und best practices. Umgang mit slicing #54.

Er schlägt eine etwas anspruchsvollere Muster zu voll befassen sich mit der Frage: haben Sie eine geschützte Kopie-Konstruktor, einem geschützten reinen virtuellen DoClone, und eine öffentliche Clone mit einem geltend machen, die Ihnen sagen, wenn eine (weitere) abgeleitete Klasse umgesetzt DoClone richtig. (Die Clone-Methode macht eine richtige Tiefe Kopie des polymorphen Objekt.)

Können Sie auch markieren Sie den copy-Konstruktor auf der Basis expliziten, das ermöglicht der explizite schneiden, wenn es erwünscht ist.

InformationsquelleAutor Steve Steiner

1. DIE DEFINITION VON SLICING-PROBLEM

Wenn D ist eine abgeleitete Klasse der Basisklasse B, so ordnen Sie ein Objekt der Abgeleiteten Typ einer Variablen (oder parameter) vom Typ Base.

BEISPIEL

class Pet
{
 public:
    string name;
};
class Dog : public Pet
{
public:
    string breed;
};

int main()
{   
    Dog dog;
    Pet pet;

    dog.name = "Tommy";
    dog.breed = "Kangal Dog";
    pet = dog;
    cout << pet.breed; //ERROR

Obwohl die obige Zuweisung erlaubt ist, der Wert, der der Variablen zugewiesen pet verliert seine Rasse Feld. Dies nennt man die slicing-problem.

2. SO BEHEBEN SIE DAS SLICING-PROBLEM

Zu besiegen, das problem, wir verwenden Zeiger auf dynamische Variablen.

BEISPIEL

Pet *ptrP;
Dog *ptrD;
ptrD = new Dog;         
ptrD->name = "Tommy";
ptrD->breed = "Kangal Dog";
ptrP = ptrD;
cout << ((Dog *)ptrP)->breed; 

In diesem Fall werden keine Daten der Mitglieder oder member-Funktionen der dynamischen Variablen
wird darauf von ptrD (Nachfahren der Klasse object) verloren. Darüber hinaus, wenn Sie Funktionen verwenden zu können, muss die Funktion sein, die eine virtuelle Funktion.

InformationsquelleAutor haberdar

OK, ich werde es versuchen, nach dem Lesen vieler Beiträge erklären, Objekt aufschneiden, aber nicht wie es wird problematisch.

Den Teufelskreis Szenario, das zu einer Speicherbeschädigung führen kann, ist die folgende:

• Klasse stellt (versehentlich, möglicherweise vom compiler generiert) Zuordnung auf eine polymorphe Basisklasse.
• Client kopiert und Scheiben eine Instanz von einer abgeleiteten Klasse.
• Client ruft eine virtuelle member-Funktion, die auf die in Scheiben geschnitten-off-Zustand.

InformationsquelleAutor Dude

class A 
{ 
    int x; 
};  

class B 
{ 
    B( ) : x(1), c('a') { } 
    int x; 
    char c; 
};  

int main( ) 
{ 
    A a; 
    B b; 
    a = b;     //b.c == 'a' is "sliced" off
    return 0; 
}

InformationsquelleAutor quidkid

Wenn eine Abgeleitete Klasse Objekt zugeordnet ist Basis-Objekt-Klasse, die für alle Mitglieder der abgeleiteten Klasse ein Objekt wird kopiert-Basis-Klasse-Objekt, mit Ausnahme der Mitglieder, die nicht anwesend sind in der base-Klasse. Diese Mitglieder werden in Scheiben Geschnitten Weg durch den compiler.
Dies wird als Objekt Schneiden.

Hier ist ein Beispiel:

#include<bits/stdc++.h>
using namespace std;
class Base
{
    public:
        int a;
        int b;
        int c;
        Base()
        {
            a=10;
            b=20;
            c=30;
        }
};
class Derived : public Base
{
    public:
        int d;
        int e;
        Derived()
        {
            d=40;
            e=50;
        }
};
int main()
{
    Derived d;
    cout<<d.a<<"\n";
    cout<<d.b<<"\n";
    cout<<d.c<<"\n";
    cout<<d.d<<"\n";
    cout<<d.e<<"\n";


    Base b = d;
    cout<<b.a<<"\n";
    cout<<b.b<<"\n";
    cout<<b.c<<"\n";
    cout<<b.d<<"\n";
    cout<<b.e<<"\n";
    return 0;
}

Generiert:

[Error] 'class Base' has no member named 'd'
[Error] 'class Base' has no member named 'e'

InformationsquelleAutor Ghulam Moinul Quadir