c++对象切割(Object Slicing)

以你之姓@ 2021-06-24 15:57 538阅读 0赞

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

**对象切割**会发生什么呢？

#include "stdafx.h"
    #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=▭//多态实现，
    	pShape->draw();
    
    	((CShape*)(&rect))->draw(); //派生类指针强制转化为基类指针，不会造成对象切割
    
    	system("pause");
    	return 0;
    }

输出结果为：

This is a  shape!
    1
    This is a  shape!
    1
    This is a  shape!
    1
    This is a  rect!
    1
    This is a  rect!
    1
    请按任意键继续……

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

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

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

注意下面两句的不同

\*pShape=rect;//**对象切割**  
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）a\_boject=b\_object;调用default A::operator =，由编译器自动生成，它的函数声明大致类似于：A operator = (A rhs)，反正=号右边要求是一个A的对象，bobject作为A的子类对象亦是可行的，只不过传递过程中会产生“截断”。

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

这时，单单重载B::operator =也无济于事，因为你无法改变operator =函数参数必须是B对象的这个事实。要实现b\_object=a\_boject;可以重载强制类型转换函数，也可以利用编译器隐式类型转换的能力，如：

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可避免对象切割。

### 基类指针与派生类指针的相互转换   ###

1，直接用基类指针引用基类对象  
2，直接用派生类指针引用派生类对象  
3，用基类指针引用一个派生类对象，由于派生类对象也是基类的对象，所以这种引用是安全的，  
但是只能引用基类成员。若试图通过基类指针引用那些只在派生类中才有的成员，编译器会报告语法错误。（解决该问题的答案是虚函数和多态性）  
4，用派生类指针引用基类的对象。这种引用方式会导致语法错误。派生类指针必须先强制转换为基类指针，这种方法是安全的。

而在侯捷的深入浅出MFC中第二章C++重要性质中:  
1、如果你以一个"基类之指针"指向一个"派生类之对象"，那么经由该指针你只能调用该基类所定义的函数  
2、如果你以一个“派生类之指针”指向一个“基类之对象”，你必须先做明显的转型操作(explicit cast)，这种作法很危险。  
3、如果基类和派生类都定义了“相同名称之函数”，那么通过对象指针调用成员函数时，到底调用了那个函数，必须视该指针的原始类型而定，而不是视指针实际所指的对象的类型而定，这与第1点其实意义相通。

#include <iostream>
    #include <stdlib.h>
    using namespace std;
    class A
    {
    public:
      char str[20];
      void f(){cout<<"class A"<<endl;}
      void fff(){cout<<"class A's str "<<str<<endl;}  
      void add(){cout<<"class A address: "<<this<<endl;}
    };
    class B:public A
    {
    public:
      int i;
      char sb[20];
      B(){cout<<"class B constructor is run."<<endl;}
      ~B(){cout<<"class B destructor is run."<<endl;}
      void f(){cout<<"class B"<<endl;}
      void ff(){cout<<"class B "<<i<<str<<sb<<endl;}
      void add(){cout<<"class B address: "<<this<<endl;}
    };
    int main(int argc, char *argv[])
    {
      //声明父类对象 
      A b;
      //声明父类对象的指针，指向父类对象 
      A *pa=&b;
      pa->add();
      //这个写法正确,不过很危险,因为pa到底是指向B还是A是不确定的.如果能明确的知道
      //pa是指向B类对象的,就如现在写的这个,那么没问题,如果pa指向A类对象,就会存在
      //风险.改变指针的类型，并不会影响内存分配既不会调用构造函数
    
      B *pb=(B *)pa;
      //类型强制转化后,指向的地址相同. 但会按转化类型访问数据成员.
      //成员函数属于类而不属于对象.各对象共用类的成员函数.强制转换成 B 类型后,可
      //调用类的成员函数。编译pb->add();后的代码只是调用add函数的时候传入了pb的对
      //象指针this
      pb->add();
    
      //由于pa指向的是父类对象的地址,这个指针被强制转换为派生类指针后,会出现内存越
      //界访问的情况,是不安全的. 
      pb->i=100;
      char dsd[100];
      strcpy(pb->sb, " class B's sb.");
      strcpy(pb->str, " class A's str.");
    
      //pb->f()调用的具体函数，视指针的原始类型而定，而不是视指针实际所指的对象的
      //类型而定.如果是虚函数，则视实际所指的对象的类型而定 
      pb->f();
      pb->ff();
      pb->fff();
    
      system("PAUSE"); 
      return 0;
    }

基类代表着最少的确定的信息，而派生类则代表着较多的确定的信息。

一个基类的指针可以指向一个派生类的对象，意味着一个指针可以指向一个容纳了多于自己期望的信息量的对象。那么当这样的一个操作发生后，这个指针就可以做出一些额外的操作，这些操作是它在被定义的时候并没有期望能够做到的，或者说并没有想到的。

与此相对的是，一个派生类的指针则不能指向一个基类的对象。因为如果可以这样做的话，那么这个派生类的指针在被定义的时候所期望能做的所有事情中将有一部分不再能够做到，因为在它指向的那个基类的对象中根本就没有提供那些在派生类派生的时候新增加的方法。但是C++则保证一个指针定义之后，它至少要能够做和它被期望做的一样多的事情。那么，派生类指针指向基类对象的意图当然不能被允许。

附一段比较有趣的代码：

// virtual Function.cpp : 定义控制台应用程序的入口点。
    #include "stdafx.h"
    #include <iostream>
    using namespace std;
    class IHello
    {
    public:
    	virtual void hello1() = 0;
    	virtual void hello2() = 0;
    };
    class IWorld
    {
    public:
    	virtual void world1() = 0;
    	virtual void world2() = 0;
    };
    class HelloWorld: public IHello,public IWorld
    {
    public:
    	void hello1();
    	void hello2();
    	void world1();
    	void world2();
    };
    void HelloWorld::hello1()
    {
    	cout<<"hello1!"<<endl;
    }
    void HelloWorld::hello2()
    {
    	cout<<"hello2!"<<endl;
    }
    void HelloWorld::world1()
    {
    	cout<<"world1!"<<endl;
    }
    void HelloWorld::world2()
    {
    	cout<<"world2!"<<endl;
    }
    int _tmain(int argc, _TCHAR* argv[])
    {
    	IHello* pIHello = new HelloWorld;
    	IWorld* pIWorld = (IWorld*)(void*)pIHello;
    	cout<<"********************First test********************"<<endl;
    	pIWorld->world1();
    	pIWorld->world2();
    
    	cout<<"********************Second test********************"<<endl;
    	pIWorld = new HelloWorld;
    	pIWorld->world1();
    	pIWorld->world2();
    
    
    	system("pause");
    	return 0;
    }