假设我们已经有了类的层次结构，例如

class Shape { virtual void get_area() = 0; };
class Square : Shape { ... };
class Circle : Shape { ... };
etc.

现在假设我想(有效地)向 Shape 添加一个 virtual draw() = 0 方法，并在每个子类中使用适当的定义。 但是，假设我想在不修改这些类的情况下执行此操作(因为它们是我不想更改的库的一部分)。

解决此问题的最佳方法是什么？

我是否真的“添加”了一个 virtual 方法并不重要，我只想要给定一个指针数组的多态行为。

我的第一个想法是这样做:

class IDrawable { virtual void draw() = 0; };
class DrawableSquare : Square, IDrawable { void draw() { ... } };
class DrawableCircle : Circle, IDrawable { void draw() { ... } };

然后用 DrawableSquare 和 DrawableCircle 替换所有 Square 和 Circle 的创建，分别。

这是完成此任务的最佳方法，还是有更好的方法(最好是让 Square 和 Circle 的创建完好无损)。

提前致谢。

最佳答案

(我确实提出了进一步的解决方案......请耐心等待......)

(几乎)解决您的问题的一种方法是使用访问者设计模式。像这样:

class DrawVisitor
{
public:
  void draw(const Shape &shape); // dispatches to correct private method
private:
  void visitSquare(const Square &square);
  void visitCircle(const Circle &circle);
};

然后代替这个:

Shape &shape = getShape(); // returns some Shape subclass
shape.draw(); // virtual method

你会这样做:

DrawVisitor dv;
Shape &shape = getShape();
dv.draw(shape);

通常在访问者模式中，您会像这样实现 draw 方法:

DrawVisitor::draw(const Shape &shape)
{
  shape.accept(*this);
}

但这只有在 Shape 层次结构设计为可访问的情况下才有效:每个子类通过调用适当的 visitXxxx 来实现虚拟方法 accept访问者的方法。它很可能不是为此而设计的。

如果无法修改类层次结构以将虚拟 accept 方法添加到 Shape(以及所有子类)，您需要一些其他方式来分派(dispatch)到正确的 绘制方法。一种天真的方法是这样的:

DrawVisitor::draw(const Shape &shape)
{
  if (const Square *pSquare = dynamic_cast<const Square *>(&shape))
  {
    visitSquare(*pSquare);
  }
  else if (const Circle *pCircle = dynamic_cast<const Circle *>(&shape))
  {
    visitCircle(*pCircle);
  }
  // etc.
}

这会起作用，但是以这种方式使用 dynamic_cast 会影响性能。如果您负担得起，这是一种简单易懂的方法，易于理解、调试、维护等。

假设有一个所有形状类型的枚举:

enum ShapeId { SQUARE, CIRCLE, ... };

还有一个虚拟方法 ShapeId Shape::getId() const = 0; 每个子类都会覆盖它以返回其 ShapeId。然后，您可以使用大量的 switch 语句而不是 dynamic_cast 的 if-elsif-elsif 来进行分派(dispatch)。或者也许可以使用哈希表代替 switch。最好的情况是把这个映射函数放在一个地方，这样你就可以定义多个访问者，而不必每次都重复映射逻辑。

所以您可能也没有 getid() 方法。太糟糕了。获取对每种类型的对象唯一的 ID 的另一种方法是什么？ RTTI。这不一定优雅或万无一失，但您可以创建一个 type_info 指针的哈希表。您可以在一些初始化代码中构建此哈希表或动态构建它(或两者)。

DrawVisitor::init() // static method or ctor
{
  typeMap_[&typeid(Square)] = &visitSquare;
  typeMap_[&typeid(Circle)] = &visitCircle;
  // etc.
}

DrawVisitor::draw(const Shape &shape)
{
  type_info *ti = typeid(shape);
  typedef void (DrawVisitor::*VisitFun)(const Shape &shape);
  VisitFun visit = 0; // or default draw method?
  TypeMap::iterator iter = typeMap_.find(ti);
  if (iter != typeMap_.end())
  {
    visit = iter->second;
  }
  else if (const Square *pSquare = dynamic_cast<const Square *>(&shape))
  {
    visit = typeMap_[ti] = &visitSquare;
  }
  else if (const Circle *pCircle = dynamic_cast<const Circle *>(&shape))
  {
    visit = typeMap_[ti] = &visitCircle;
  }
  // etc.

  if (visit)
  {
    // will have to do static_cast<> inside the function
    ((*this).*(visit))(shape);
  }
}

可能存在一些错误/语法错误，我还没有尝试编译这个例子。我以前做过类似的事情——这项技术很管用。不过，我不确定您是否会遇到共享库问题。

我要补充的最后一件事:无论您决定如何进行调度，创建一个访问者基类可能是有意义的:

class ShapeVisitor
{
public:
  void visit(const Shape &shape); // not virtual
private:
  virtual void visitSquare(const Square &square) = 0;
  virtual void visitCircle(const Circle &circle) = 0;
};

关于c++ - 在不修改原有类的情况下添加虚函数，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/2352533/