如果您有一个基类a和一个派生类B，那么您可以执行以下操作。

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

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

现在，方法wantAnA需要派生的副本。然而，派生的对象不能完全复制，因为类B可以创建不在其基类A中的其他成员变量。

因此，要调用wantAnA，编译器将“切片”派生类的所有其他成员。结果可能是您不想创建的对象，因为

它可能是不完整的，它的行为类似于A对象（B类的所有特殊行为都丢失了）。

这里的大多数答案都无法解释切片的实际问题。它们只解释了切片的良性情况，而不是不可靠的情况。与其他答案一样，假设您处理的是两个类A和B，其中B（公开）来自A。

在这种情况下，C++允许您将B的实例传递给A的赋值运算符（以及复制构造函数）。这之所以有效，是因为B的实例可以转换为常量a&，这是赋值运算符和复制构造函数希望它们的参数是什么。

良性病例

B b;
A a = b;

没有什么不好的事情发生——你要求A的实例是B的副本，这正是你得到的。当然，a不会包含b的一些成员，但它应该怎么做？毕竟，它是A，而不是B，所以它甚至没有听说过这些成员，更不用说能够存储它们了。

背信弃义的案子

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

你可能会认为b2会是b1的复制品。但是，唉，这不是！如果你检查它，你会发现b2是一种弗兰肯斯坦生物，由b1的一些块（B从a继承的块）和b2的一些块组成（只有B包含的块）。哎哟

怎么搞的？默认情况下，C++不会将赋值运算符视为虚拟运算符。因此，行a_ref=b1将调用a的赋值运算符，而不是B的赋值运算符。这是因为，对于非虚拟函数，声明的（形式上：静态）类型（即a&）决定调用哪个函数，而不是实际的（形式：动态）类型（由于a_ref引用了B的实例，因此将是B）。现在，A的赋值运算符显然只知道A中声明的成员，因此它将只复制那些成员，而保留B中添加的成员不变。

解决方案

只分配给对象的一部分通常意义不大，但不幸的是，C++没有提供内置的方法来禁止这种情况。不过，你可以自己动手。第一步是使赋值运算符虚拟化。这将确保调用的始终是实际类型的赋值运算符，而不是声明的类型。第二步是使用dynamic_cast验证指定的对象是否具有兼容类型。第三步是在（protected！）成员assign（）中进行实际赋值，因为B的assign（（）可能希望使用a的assign）复制a的成员。

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
  }
};

注意，为了方便起见，B的运算符=协变地重写返回类型，因为它知道它返回的是B的一个实例。

C++中的切片问题源于其对象的值语义，这主要是由于与C结构的兼容性。您需要使用显式引用或指针语法来实现大多数其他语言中的“正常”对象行为，即对象总是通过引用传递。

简单的答案是，通过按值将派生对象分配给基础对象来切片对象，即，剩余对象只是派生对象的一部分。为了保持值语义，切片是一种合理的行为，其用途相对较少，这在大多数其他语言中都不存在。有些人认为它是C++的一个特性，而许多人则认为这是C++的怪癖/错误特性之一。

1.切片问题的定义

如果D是基类B的派生类，则可以将派生类型的对象分配给base类型的变量（或参数）。

例子

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

尽管上面的赋值是允许的，但赋值给变量宠物的值将丢失其品种字段。这被称为切片问题。

2.如何解决切片问题

为了解决这个问题，我们使用指向动态变量的指针。

例子

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

在这种情况下，没有动态变量的数据成员或成员函数被ptrD（后代类对象）指向的对象将丢失。此外，如果需要使用函数，则函数必须是虚拟函数。

切片问题很严重，因为它会导致内存损坏，而且很难保证程序不会受到这种问题的困扰。要用语言设计它，支持继承的类应该只能通过引用（而不是通过值）访问。D编程语言具有此属性。

考虑从A派生的类A和类B。如果A部分有一个指针p，而B实例指向B的附加数据，则可能发生内存损坏。然后，当附加数据被切片时，p指向垃圾。

我刚刚遇到了切片问题，很快就到了这里。所以让我再加上两美分。

让我们来举一个“生产代码”（或类似代码）的例子：

假设我们有一个可以调度动作的东西。例如，控制中心UI。此UI需要获取当前可以调度的事物的列表。因此，我们定义了一个包含分派信息的类。让我们称之为行动。因此，Action有一些成员变量。为了简单起见，我们只有2，即std:：string名称和std:：function＜void（）＞f。然后它有一个void activate（），它只执行f成员。

因此，UI得到了一个std:：vector<Action>。设想一些功能，如：

void push_back(Action toAdd);

现在，我们已经从UI的角度确定了它的外观。到目前为止没有问题。但是另一个从事这个项目的人突然决定，Action对象中有一些特殊的动作需要更多的信息。无论出于什么原因。这也可以通过lambda捕获来解决。此示例并非取自代码1-1。

所以这家伙从《行动》中派生出来，以增添自己的味道。他将自己制作的课程的一个实例传递给push_back，但随后程序就失控了。

那发生了什么？正如您可能已经猜到的：对象已被切片。

实例中的额外信息已经丢失，f现在容易出现未定义的行为。

我希望这个例子能给那些在谈论以某种方式派生的A和B时无法真正想象事情的人带来启发。