c++对象切割

         这篇问章写得很好很清晰。

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

对象切割会发生什么呢？

[cpp]  view plain copy

1. #include <iostream>  
2. using namespace std;  
3. class CShape  
4. {  
5. public:  
6.     CShape ()  
7.     {  
8.         m_color=0;  
9.     }  
10.       
11.     ~CShape(){}  
12.       
13.     virtual void draw()  
14.     {  
15.         cout<<"This is a shape!"<<endl;  
16.         cout<<m_color<<endl;  
17.     }  
18.       
19.     double m_color;  
20.       
21. };  
22.   
23. class CRect: public CShape  
24. {  
25. public:  
26.     CRect()  
27.     {  
28.         m_width=5;  
29.         m_height=4;  
30.         m_color=1;  
31.     }  
32.     ~CRect(){};  
33.       
34.     double size()  
35.     {  
36.         return m_width*m_height;  
37.     }  
38.   
39.     virtual void draw()  
40.     {  
41.         cout<<"This is a rect!"<<endl;  
42.         cout<<m_color<<endl;  
43.     }  
44.       
45.     double  m_width;  
46.     double  m_height;  
47. };  
48.   
49. int main(int argc, char* argv[])  
50. {  
51.     CShape shp;  
52.     CRect rect;  
53.     shp = rect;  
54.     shp.draw();  
55.     ((CShape)rect).draw();//注意此行  
56.       
57.     CShape *pShape=new CShape();  
58.   
59.     *pShape=rect;//对象切割  
60.     pShape->draw();  
61.   
62.   
63.   
64.     pShape=&rect;//多态实现，  
65.     pShape->draw();  
66.       
67.       
68.     return 0;  
69. }  

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

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

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

注意下面两句的不同

*pShape=rect;//对象切割

CShape& s = rect;//#add应该也会导致对象切割
pShape=&rect;//多态

 

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

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

有关

（1）a_boject＝b_object；

（2）b_object＝a_boject；

的说明。

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

（2）bobject=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;
}