在c++中,什么是对象切片,什么时候发生?


当前回答

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

其他回答

这里的大多数答案都无法解释切片的实际问题。它们只解释了切片的良性情况,而不是不可靠的情况。与其他答案一样,假设您处理的是两个类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的一个实例。

好的,在阅读了许多解释对象切片的文章后,我会尝试一下,但不知道它是如何变得有问题的。

可能导致内存损坏的恶性场景如下:

类在多态基类上提供(意外地,可能是编译器生成的)赋值。客户端复制并切片派生类的实例。客户端调用一个虚拟成员函数,该函数访问切片状态。

我看到所有的答案都提到了当数据成员被切片时对象切片发生的情况。这里我举了一个示例,说明这些方法不会被重写:

class A{
public:
    virtual void Say(){
        std::cout<<"I am A"<<std::endl;
    }
};

class B: public A{
public:
    void Say() override{
        std::cout<<"I am B"<<std::endl;
    }
};

int main(){
   B b;
   A a1;
   A a2=b;

   b.Say(); // I am B
   a1.Say(); // I am A
   a2.Say(); // I am A   why???
}

B(对象B)从A(对象a1和a2)导出。正如我们所期望的,b和a1调用它们的成员函数。但从多态性的角度来看,我们不期望由b赋值的a2不会被重写。基本上,a2只保存b的A类部分,即C++中的对象切片。

要解决此问题,应使用引用或指针

 A& a2=b;
 a2.Say(); // I am B

or

A* a2 = &b;
a2->Say(); // I am B

当派生类对象被分配给基类对象时,派生类对象的其他属性将从基类对象中切下(丢弃)。

class Base { 
int x;
 };

class Derived : public Base { 
 int z; 
 };

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

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(后代类对象)指向的对象将丢失。此外,如果需要使用函数,则函数必须是虚拟函数。