在继承类中使用覆盖方法时的循环依赖性

Question

我有以下情况。

class GenericObject{
virtual Attribute* getAttribute(){..}
}

class PlaneObject : public GenericObject{
Attribute1* getAttribute()override{..}
}

-----------------------------------------块1

class Attribute{
virtual GenericObject* getObject(){..}
}

class Attribute1 : public Attribute{
PlaneObject* getObject()override{..}
}

----------------------------------------块2。

由于我重写了PlaneObject中的getAttribute()方法，把它的返回类型从Attribute*改为Attribute1*，只有当编译器知道Attribute1是从Attribute派生出来的时候，才允许这样做。

那么我应该把block2放在block1之前。

但是，block2也需要知道PlaneObject是从GenericObject派生出来的，才能编译，因为Attribute1类中有重载方法。

我不知道这是否是不好的设计模式，或者是什么，我一直在寻找类似的问题，但没有找到我所面临的完全相同的图片。

Answer 1

没有简单的解决办法.你可以尝试用这种方式来打破循环。

// GenericObject.h
class Attribute;
class GenericObject{
virtual Attribute* getAttribute();
};

// Attribute.h
class GenericObject;
class Attribute{
virtual GenericObject* getObject();
};

// PlaneObject.h
#include "GenericObject.h"
class Attribute1;
class PlaneObject : public GenericObject
{
Attribute* getAttribute()override;
Attribute1* getAttributeRealType();
};

// Attribute1.h
#include "Attribute.h"
class PlaneObject;
class Attribute1 : public Attribute{
GenericObject* getObject()override;
PlaneObject* getObjectRealType();
};

// implementation example
// PlaneObject.cpp
#include "PlaneObject.h"
#include "Attrubute1.h"
Attribute* PlaneObject::getAttribute()
{
    return getAttributeRealType();
}
Attribute1* PlaneObject::getAttributeRealType()
{
    return new Attribute1;
}
// attribute1.cpp
#include "Attribute1.h"
#include "PlaneObject.h"
GenericObject* Attribute1::getObject()
{
   return getObjectRealType();
}
PlaneObject* Attribute1::getObjectRealType()
{
   return new PlaneObject;
}