Question

对于上下文，我正在研究一个涉及由递归神经网络控制的代理的C ++ artificial-life system，但细节并不重要。

我需要为我的代理人的“大脑”和“身体”分开保留两个对象层次结构。我想要各种不同的大脑和身体类型，可以在运行时相互耦合。我需要做到这一点，以避免由身体如何工作和大脑如何工作的单独关注的乘法枚举引起的组合爆炸。

例如，有许多具有各种不同传递函数和输入/输出约定的递归神经网络的拓扑和样式。然而，只要感觉输入可以编码到神经活动中然后解码为动作，这些细节不依赖于代理的身体如何工作。

这是一个简单的类层次结构，它说明了问题和一个潜在的解决方案：

// Classes we are going to declare

class Image2D; // fake
class Angle2D; // fake

class Brain;    
class Body;      
class BodyWithEyes;
class BrainWithVisualCortex;

// Brain and Body base classes know about their parallels

class Brain
{
  public:
    Body* base_body;

    Body* body() { return base_body; }
    virtual Brain* copy() { return 0; } // fake

    // ...etc
};

class Body
{
  public:
    Brain* base_brain;

    Brain* brain() { return base_brain; }
    virtual Body* reproduce() { return 0; } // fake

    // ...etc
};

// Now introduce two strongly coupled derived classes, with overloaded access
// methods to each-other that return the parallel derived type

class BrainWithVisualCortex : public Brain
{
  public:
    BodyWithEyes* body();
    virtual void look_for_snakes();
    virtual Angle2D* where_to_look_next() { return 0; } // fake
};

class BodyWithEyes : public Body
{
  public:
    BrainWithVisualCortex* brain();
    virtual void swivel_eyeballs();
    virtual Image2D* get_image() { return 0; } // fake
};

// Member functions of these derived classes

void BrainWithVisualCortex::look_for_snakes()
{
  Image2D* image = body()->get_image();

  // ... find snakes and respond
}

void BodyWithEyes::swivel_eyeballs()
{
  Angle2D* next = brain()->where_to_look_next();

  // ... move muscles to achieve the brain's desired gaze
}

// Sugar to allow derived parallel classes to refer to each-other

BodyWithEyes* BrainWithVisualCortex::body()  
{ return dynamic_cast<BodyWithEyes*>(base_body); }

BrainWithVisualCortex* BodyWithEyes::brain() 
{ return dynamic_cast<BrainWithVisualCortex*>(base_brain); }

// pretty vacuous test
int main()
{
  BodyWithEyes* body = new BodyWithEyes;
  BrainWithVisualCortex* brain = new BrainWithVisualCortex;
  body->base_brain = brain;
  brain->base_body = body;
  brain->look_for_snakes();
  body->swivel_eyeballs();
}

这种方法的问题在于它很笨重而且不是特别类型安全的。它确实有一个好处，即body（）和brain（）成员函数为派生类提供一些糖来引用它们的伙伴。

有没有人知道在类的“并行”层次结构之间实现这种紧密耦合的更好方法？这种模式是否经常出现，以保证一个众所周知的通用解决方案？仔细阅读通常的消息来源并未发现任何符合此问题的既定模式。

任何帮助表示赞赏！

Answer 1

我认为你所做的是近似正确的。但是，您希望reproduce之类的成员是纯虚拟的，因此无法创建基类。你的类型安全问题是什么？您不希望Brain子类和Body子类依赖于彼此的类型。

C ++中紧密耦合的并行类层次结构

1 个答案: