c++类设计为每个不同的行为提供多个接口

    class IComposerBehavior;
    class IComposer
    {
       public:
          virtual ~IComposer() {}
          virtual void accept(IComposerBehavior *behaviour) = 0 ;
    };
    class IComposerBehavior
    {
       public:
          virtual ~IComposerBehavior() {}
          virtual void visit(IComposer * ) = 0;
    };
    class Dude : public IDude, public IComposer
    {
        public:
          virtual void accept(IDudeBehavior *behaviour)
          {
              behaviour->visit(this);
          }
          virtual void accept(IComposerBehavior *behaviour)
          {
              behaviour->visit(this);
          }
    };
    class SymphonyComposerBehavior : public IComposerBehavior
    {
      public:
         virtual void visit(IComposer *dude) { cout << "Dude is composing a symphony" << endl;   }
    };

- Initially We are only producing Toy Robots
- Then Human helper Robots
- Then Self Healing Robots (would just correct itself when defective)
- Then Humanoid Robots
- Then machine Robots (that are not human like but as a substitute for any machine you can think of) . I have deliberately put this here even though its place should be before with a correct evolution scheme.
- finally Humanoid Robots with life (atleast we can dream :-) )

我想面试官希望你谈谈访问者模式。

是的，访问者模式允许您向现有的类结构中添加新的行为，而无需向结构中进一步添加/派生类/接口。它只需要实现行为，而访问者模式允许您将此行为添加到类的结构中。

阅读这个wiki条目;它解释了模式:

• 访问者模式

下面是访问者模式的一个简单实现:

class IDudeBehavior;
class IDude
{
   public:
      virtual ~IDude() {}
      virtual void accept(IDudeBehavior *behaviour) = 0 ;
};
class IDudeBehavior
{
   public:
      virtual ~IDudeBehavior() {}
      virtual void visit(IDude * ) = 0;
};
class Dude : public IDude
{
    public:
      virtual void accept(IDudeBehavior *behaviour)
      {
          behaviour->visit(this);
      }
};
class LaughDudeBehavior : public IDudeBehavior
{
  public:
     virtual void visit(IDude *dude) { cout << "Dude is Laughing" << endl; }
};
class WalkDudeBehavior : public IDudeBehavior
{
  public:
     virtual void visit(IDude *dude) { cout << "Dude is Walking" << endl; }
};
int main() {
        IDude *dude = new Dude();
        dude->accept(new LaughDudeBehavior());
        dude->accept(new WalkDudeBehavior());
        return 0;
}

在线演示:http://ideone.com/Kqqdt

到目前为止，类Dude只有两个行为，即LaughDudeBehavior和WalkDudeBehavior，但由于它是一个访问者模式，您可以向Dude添加任意数量的行为，而无需编辑类Dude。例如，如果您想添加EatDudeBehavior和StudyCplusCplusDudeBehavior，那么您只需要将IDudeBehavior实现为:

class EatDudeBehavior : public IDudeBehavior
{
  public:
     virtual void visit(IDude *dude) { cout << "Dude is Eating" << endl; }
};
class StudyCplusCplusDudeBehavior : public IDudeBehavior
{
  public:
     virtual void visit(IDude *dude) { cout << "Dude is Studying C++" << endl; }
};

然后你需要接受这些行为

dude->accept(new EatDudeBehavior ()); 
dude->accept(new StudyCplusCplusDudeBehavior ());

添加这些新行为后的演示:http://ideone.com/9jdEv

---

避免内存泄漏

上面的代码有一个问题。一切看起来都很好，除了内存泄漏。该程序使用new创建了许多类的实例，但从未使用delete释放它们。所以你也需要考虑一下这个

内存泄漏可以很容易地修复:

int main() {
        IDude *dude = new Dude();
        std::vector<IDudeBehavior*>  behaviours;
        behaviours.push_back(new LaughDudeBehavior());
        behaviours.push_back(new WalkDudeBehavior());
        behaviours.push_back(new EatDudeBehavior());
        behaviours.push_back(new StudyCplusCplusDudeBehavior());
        for(size_t i = 0 ; i < behaviours.size() ; i++ )
           dude->accept(behaviours[i]);
        //deallcation of memory!
        for(size_t i = 0 ; i < behaviours.size() ; i++ )
           delete behaviours[i];
        delete dude;
        return 0;
}

现在没有内存泄漏。

(…)将来会出现带有新行为集的新类

这里有两个不同的东西。新的类和新的行为集。

---

如果不添加新类，这意味着您有一组固定的类和大量的行为:这使得访问者模式成为潜在的候选者。访问者模式的目标是将行为转换为类，并允许它在其作用的层次结构的类上模式匹配(不强制转换)。

然而，Visitor实现起来很麻烦，并且如果层次结构非常简单(即。只有两个主要分支你想要区分)，你最好实现行为作为自由函数，并使用dynamic_cast来选择对象的行为属于层次结构的哪个分支。查看dynamic_cast的合理用例。

使用Visitor(或简单的dynamic_cast调度，如果适用)的真正优点是，与行为相关的完整代码只在一个地方维护。这与接口的情况不同，接口的每个实现可能分散在各种实现文件中。

---

现在，如果必须添加一堆新类，并且行为集是固定的，那么使用和滥用接口是正确的方法。接口对于抽象行为非常有用。然而，一旦行为数量增加，维护起来就很麻烦，因为代码在各种类实现文件中变得混乱。

参见模板方法模式，它可以应用在这里。

请参见这个关于接口不可思议的有用性的问题。

---

如果类的数量和行为的数量增加会怎样?恐怕没有独立解决问题的好办法。你唯一的办法就是聪明地抽象，这样不同的行为就不必关心它们作用于哪个类了。

考虑下面的例子。你有n容器类(vector, list, deque, set等)，和m算法(find_if, count, copy, for_each等)。

你不能在每个容器类中实现每个算法:这意味着你必须编写O(nm)代码。标准库保留的解决方案是抽象结构体的遍历:每个容器类都公开一对迭代器，算法作用于迭代器对。这允许编写O(n + m)个代码。

---

总之，在状态类和行为数量不断增加的情况下，您必须找到使行为真正独立于状态类的抽象。这是没有设计模式的:你必须动动脑子。

在存在固定数量的状态类和增加数量的行为的情况下，要么正确抽象，要么最后使用Visitor。

当存在越来越多的状态类和固定数量的行为时，使用接口:这就是它们的作用。