对象切片，有优势吗？

Question

对象切片是指当子类分配给基类时，对象会丢失其某些属性或功能。 比如

Class A{

}
Class B extends A{

}

Class SomeClass{
A a = new A();
B b = new B();

// Some where if might happen like this */
a = b; (Object slicing happens)

}

我们说对象切片有什么好处吗？ 如果是，有人可以告诉我对象切片对开发有何帮助以及它在哪些方面可能有帮助吗？

Answer 1

在 C++ 中，您应该将对象切片视为从派生类型到基类型[*]的转换。一个全新的物体被创造出来，它的灵感来自于一个真实的故事。

有时这是您想要做的事情，但结果在任何意义上都与原始对象不同。当对象切片出错时，人们没有注意，并认为它是同一个对象或其副本。

通常这没有什么好处。事实上，当有人本打算通过引用传递时却通过值传递，这通常是意外完成的。

很难举出一个例子来说明何时切片绝对是正确的做法，因为很难（尤其是在 C++ 中）举出一个非抽象基类绝对是正确的做法的例子。这是一个重要的设计点，不能轻易忽略 - 如果您发现自己有意或无意地切片了一个对象，很可能您的对象层次结构一开始就是错误的。要么基类不应该用作基类，要么它应该至少有一个纯虚函数，因此不能按值切片或传递。

因此，我给出的任何将对象转换为其基类的对象的示例都会正确地引发反对意见，“等一下，您首先要从具体类继承做什么？”。如果切片是偶然的，那么它可能是一个错误，如果是故意的，那么它可能是“代码味道”。

但答案可能是“是的，好吧，这不应该确实是事物的结构方式，但考虑到它们是这样构建的，我需要从派生类到基类，并且根据定义是一个切片”。本着这种精神，这里有一个示例：

struct Soldier {
    string name;
    string rank;
    string serialNumber;
};

struct ActiveSoldier : Soldier {
    string currentUnit;
    ActiveSoldier *commandingOfficer; // the design errors multiply!
    int yearsService;
};

template <typename InputIterator>
void takePrisoners(InputIterator first, InputIterator last) {
    while (first != last) {
        Soldier s(*first);
        // do some stuff with name, rank and serialNumber
       ++first;
    }
}

现在，takePrisoners 函数模板的要求是其参数是可转换为 Soldier 的类型的迭代器。它不一定是派生类，并且我们不直接访问成员“名称”等，因此 takePrisoners 尝试提供最简单的接口来实现给定的限制（a ) 应该与 Soldier 一起使用，并且 (b) 应该可以编写它也可以使用的其他类型。

ActiveSoldier 就是另一种类型。由于只有该类的作者最清楚的原因，它选择公开继承 Soldier，而不是提供重载的转换运算符。我们可以争论这是否是一个好主意，但我们假设我们坚持这样做。因为它是派生类，所以它可以转换为 Soldier。这种转换称为切片。因此，如果我们调用 takePrisoners 并传入 ActiveSoldiers 向量的 begin() 和 end() 迭代器，那么我们将对它们进行切片。

您可能会为 OutputIterator 提出类似的示例，其中接收者只关心正在传递的对象的基类部分，因此允许在将它们写入迭代器时对它们进行切片。

之所以有“代码味道”，是因为我们应该考虑 (a) 重写 ActiveSoldier，以及 (b) 更改 Soldier，以便可以使用函数而不是成员访问来访问它，这样我们就可以将这组函数抽象为一个接口，其他类型可以独立实现，因此 takePrisoners 不必转换为 Soldier。其中任何一个都将消除对切片的需求，并且对于将来可以轻松扩展我们的代码具有潜在的好处。

[*]因为它是一个。下面的最后两行做同样的事情：

struct A {
    int value;
    A(int v) : value(v) {}
};

struct B : A {
    int quantity;
    B(int v, int q) : A(v), quantity(q) {}
};

int main() {
    int i = 12;  // an integer
    B b(12, 3);  // an instance of B
    A a1 = b;    // (1) convert B to A, also known as "slicing"
    A a2 = i;    // (2) convert int to A, not known as "slicing"
}

唯一的区别是 (1) 调用 A 的复制构造函数（编译器提供，即使代码没有提供），而 (2) 调用 A 的 int 构造函数。

正如其他人所说，Java 不进行对象切片。如果您提供的代码被转换为 Java，那么就不会发生任何类型的对象切片。 Java 变量是引用，而不是对象，因此 a = b 的后置条件只是变量“a”与变量“b”引用同一个对象 - 通过一个引用进行的更改可以通过以下方式查看其他参考，等等。他们只是用不同的类型来引用它，这是多态性的一部分。一个典型的类比是，我可能将一个人视为“我的兄弟”[**]，而其他人可能将同一个人视为“我的牧师”。相同的对象，不同的接口。

你可以使用指针或引用在 C++ 中获得类似 Java 的效果：

B b(24,7);
A *a3 = &b; // No slicing - a3 is a pointer to the object b
A &a4 = b;  // No slicing - a4 is a reference to (pseudonym for) the object b

[**] 事实上，我的兄弟不是牧师。