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的类型的迭代器。它不必是派生类，我们也不直接访问成员“name”等，因此takePrisoners试图提供最简单的实现接口，因为限制（a）应该工作与士兵一起，（b）应该可以写出它也可以使用的其他类型。

ActiveSoldier就是其中一种类型。由于只有该类作者才知道的原因，它选择公开继承士兵而不是提供重载转换运算符。我们可以争辩这是不是一个好主意，但让我们假设我们坚持下去。因为它是派生类，所以它可以转换为士兵。该转换称为切片。因此，如果我们调用takePrisoners传递ActiveSoldiers向量的begin()和end()迭代器，那么我们将对它们进行切片。

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

它是“代码味道”的原因是我们应该考虑（a）重写ActiveSoldier，以及（b）改变士兵，以便可以使用函数而不是成员访问来访问它，这样我们就可以将这组函数抽象为其他类型可以独立实现的接口，因此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

事实上，我哥哥不是牧师。

对象切片，有优势吗？

1 个答案: