C++的多态问题

[pioneer_public]

class CEntity: public CObject
{
virtual CEntity *CopyEntity(CEntity *pSrc)
{
// 复制点链表到新的实体中
};

CPointList *m_pList;
}

class CStringEntity: public CObject
{
virtual CEntity *CopyEntity(CEntity *pSrc)
{
}
}

我想要调用的时候能如此写
CEntity *pBase = NULL;

switch( nEntityType )
{
case 1: //基类
pBase = pA; //(pA为基类)
break;
case 2: //CStringEntity
pBase = (CEntity *)pB; //( pB为CStringEntity类)
break;
}

CEntity *pNew = pBase->CopyEntity(pBase);

类中的多态函数如何写？？？

要求在CEntity类中不得调用子类

[pioneer_public]

这个我也晓得，

问题是我想要的不是这个。

我要的是如何基于多态进行对象复制

[fanxublue]

看不懂楼主是要干嘛... 能不能说清楚点...
WTL中的虚函数机制跟MFC不一样 你可以参考下...

[pioneer_public]

一般的多态函数返回值都是指定的如：void,double,bool等

我现在需要返回的是不定的,CEntity,CStringEntity等。

指定的很容易就可以实现

后一种父类,子类的返回值 就不容易了。而且在基类中不能使用子类。

我现在使用的方法是：

//基类中的复制对象函数
// 声明：
	// 复制相同的实体
	// virtual       CNcEntity *CopyEntity(CNcEntity *pSrc);

CNcEntity *CNcEntity::CopyEntity(CNcEntity *pSrc)
{
	if( pSrc == NULL )
		return NULL;

	if( !pSrc->IsKindOf(RUNTIME_CLASS(CNcEntity)) )
		return NULL;

	CNcEntity *pReturn = NULL;
	switch( pSrc->m_nEntityType )
	{
	case ENTITY_TYPE_OUT:
		{
			pReturn = new COutEntity;
		}
		break;
	case ENTITY_TYPE_HOLE:
		{
			pReturn = new CHoleEntity;
		}
		break;
	case ENTITY_TYPE_MARKINGDATA:
		{
			pReturn = new CMarkingData;
		}
		break;
	case ENTITY_TYPE_STRINGDATA:
		{
			pReturn = new CStringEntity;
		}
		break;
	case ENTITY_TYPE_BLASTING:
		{
			pReturn = new CBlastingData;
		}
		break;
	case ENTITY_TYPE_STARTHOOK:    //起割线
		{
			pReturn = new CStartHook;
		}
		break;
	case ENTITY_TYPE_ENDHOOK:     //终割线
		{
			pReturn = new CEndHook;
		}
		break;
	case ENTITY_TYPE_GEOMETRY:    //几何数据
		{
			pReturn = new CGeometryData;
		}
		break;
	case ENTITY_TYPE_IDLE:        //空程
		{
			pReturn = new CIdleData;
		}
		break;
	case ENTITY_TYPE_MARKINGSHAPEDATA: //MARKINGSHAPE
		{
			pReturn = new CMarkingShapeData;
		}
		break;
	case ENTITY_TYPE_LABELTEXT :    //标签
		{
			pReturn = new CLabelTextData;
		}
		break;
	case ENTITY_TYPE_LABELSYMBOL:    //符号
		{
			pReturn = new CLabelSymbolData;
		}
		break;
	case ENTITY_TYPE_GSD:           //GSD
		{
			pReturn = new CGSDData;
		}
		break;
	case ENTITY_TYPE_AUXILIARY_FUNCTION:  //辅助功能
		{
			pReturn = new CAuxiliaryFunctionData;
		}
		break;
	case ENTITY_TYPE_TAPE:    //后处理信息
		{
			pReturn = new CTapeData;
		}
		break;
	case ENTITY_TYPE_UNDEFINE:
	case ENTITY_TYPE_UNKOWN:
	default:
		{
			pReturn = new CNcEntity;
		}
		break;
	}

	CNcPoint *pTempPoint = NULL,*pLsEndPoint = NULL;
	pReturn->m_nEntityType = pSrc->m_nEntityType;
	pReturn->m_bVisible = pSrc->m_bVisible;
	
	pTempPoint = pSrc->m_pHeadPoint;
	while(pTempPoint!=NULL)
	{
		 CNcPoint *pLsPoint;
		 pLsPoint = new CNcPoint;
		 pLsPoint->r = pTempPoint->r;
		 pLsPoint->x = pTempPoint->x;
		 pLsPoint->y = pTempPoint->y;
		 pLsPoint->m_nType = pTempPoint->m_nType;

         if(pTempPoint == pSrc->m_pHeadPoint)
		 {
			 pReturn->m_pHeadPoint = pLsEndPoint = pLsPoint;
		 }
		 else
		 {
			 pLsEndPoint->m_pNextPoint = pLsPoint;
			 pLsPoint->m_pForePoint = pLsEndPoint;
			 pLsEndPoint = pLsPoint;
		 }

		 pTempPoint=pTempPoint->m_pNextPoint;
	}

	return pReturn;
}
//子类中的复制对象方法
CNcEntity *CStringEntity::CopyEntity(CNcEntity *pSrc)
{
	if( pSrc == NULL )
		return NULL;

	if( !pSrc->IsKindOf(RUNTIME_CLASS(CStringEntity) ) )
		return NULL;

	if( pSrc->m_nEntityType != ENTITY_TYPE_STRINGDATA)
		return NULL;

	CStringEntity *pReturn = (CStringEntity *)(CNcEntity::CopyEntity(pSrc));
	CStringEntity *pOSrc   = (CStringEntity *)pSrc;

	pReturn->m_dAngle     = pOSrc->m_dAngle;
	pReturn->m_dHeight    = pOSrc->m_dHeight;
	pReturn->m_dPosX      = pOSrc->m_dPosX;
	pReturn->m_dPosY      = pOSrc->m_dPosY;
	pReturn->m_string     = pOSrc->m_string;
	pReturn->m_stringType = pOSrc->m_stringType;

	return (CNcEntity *)pReturn;
}

我这个方法可以实现多态，但是基类中使用了子类。

[pioneer_public]

自己顶下

[feilinhe]

在每个类的CopyEntity里面只关心自己的类型处理就可以了啊，没必要在父类中switch...case，调用的时候就是你那样的啊

[雪影]

多态的实现是基于继承实现的.

clss a
{
virtual void fun();
}
class b: public a
{
void fun();
}

b* pb = new b;
a* pa = pb;
pa->fun();//调用的是b中的fun函数,这就是多态

[taojiaan]

自己顶一下

[pioneer_public]

问题是我必须调用基类中的复制过程。

还要返回需要的不同种类的类。

[pioneer_public]

总不能把其中必须调用的过程：如

pTempPoint = pSrc->m_pHeadPoint;
    while(pTempPoint!=NULL)
    {
         CNcPoint *pLsPoint;
         pLsPoint = new CNcPoint;
         pLsPoint->r = pTempPoint->r;
         pLsPoint->x = pTempPoint->x;
         pLsPoint->y = pTempPoint->y;
         pLsPoint->m_nType = pTempPoint->m_nType;

         if(pTempPoint == pSrc->m_pHeadPoint)
         {
             pReturn->m_pHeadPoint = pLsEndPoint = pLsPoint;
         }
         else
         {
             pLsEndPoint->m_pNextPoint = pLsPoint;
             pLsPoint->m_pForePoint = pLsEndPoint;
             pLsEndPoint = pLsPoint;
         }

         pTempPoint=pTempPoint->m_pNextPoint;
    }

在每个子类中再写一遍吧。

那还要这个多态函数干什么呢？