c++对象切割(Object Slicing)

时间:2022-09-06 11:35:05

当把一个派生类对象赋给一个基类对象时,会发生对象切割(另外用基类对象强制转换派生类对象也会)

对象切割会发生什么呢?

#include <iostream>

using namespace std;

class CShape

{

public:

          CShape ()

          {

                      m_color=0;

          }

         

          ~CShape(){}

         

          virtual void draw()

          {

                      cout<<"This is a shape!"<<endl;

                      cout<<m_color<<endl;

          }          

          double m_color;

         

};

class CRect: public CShape

{

public:

          CRect()

          {

                      m_width=5;

                      m_height=4;

                      m_color=1;

          }

          ~CRect(){};       

          double size()

          {

                      return m_width*m_height;

          }

          virtual void draw()

          {

                      cout<<"This is a rect!"<<endl;

                      cout<<m_color<<endl;

          }

         

          double m_width;

          double   m_height;

};

int main(int argc, char* argv[])

{

          CShape shp;

          CRect rect;

    shp = rect;

    shp.draw();

          ((CShape)rect).draw();//注意此行

         

          CShape *pShape=new CShape();

          *pShape=rect;//对象切割

          pShape->draw();

          pShape=&rect;//多态实现,

          pShape->draw();

         

          return 0;

}

shp=rect; 会调用 CShape的默认赋值函数,shpCShape属性值与rect相同,但其虚函数表指针指向基类CShape虚函数表。

((CShape)rect).draw(); 会调用CShape默认的拷贝构造函数,生成一个中间变量,其虚函数表指针指向基类CShape虚函数表。

多态的实现是通过指针和引用;而对象的转换只会造成对象切割,不能实现多态。

注意下面两句的不同

*pShape=rect;//对象切割
pShape=&rect;//多态

附基类和派生类对象间赋值的问题:

class A
{
}
Class B:public A
{
}
A a_object;
B b_object;

有关

1a_bojectb_object

2b_objecta_boject

的说明。

==============
1aobject=bobject; 调用default A::operator =,由编译器自动生成,它的函数声明大致类似于:A operator = (A rhs),反正=号右边要求是一个A的对象,bobject作为A的子类对象亦是可行的,只不过传递过程中会产生截断

2bobject=aobject; 调用default B::operator =,也由编译器自动生成,它的函数声明大致类似于:B operator = (B rhs),这里=号右边要求是一个B的对象,aobject这时就不可行了。(编译器将报错)

这时,单单重载B::operator =也无济于事,因为你无法改变operator = 函数参数必须是B对象的这个事实。要实现bobject=aobject;可以重载强制类型转换函数,也可以利用编译器隐式类型转换的能力,如:
class A
{
public:
A(){}
};

class B:public A
{
public:
B(){}
B(A a){}//必须有
};
A aobject;
B bobject;

int main()
{
a_object=b_object;
b_object=a_object;
return 0;
}

--------------------------------------

Class 对象作参数时,用reference to const替换pass by value可避免对象切割。