无法在 C++ 中的派生类中重载基类方法

Question

我要做什么

我正在将使用 dynamic_casting 识别派生类（形状）以应用派生类特定处理的现有代码库转换为基于访问者模式的方案。为此，我在基类（虚拟）和每个派生类中添加了一个 processMe 方法，并在 ShapeProcessor 类中添加了一个 handleShape 方法，用于处理每种类型的形状，这是访问者模式的典型。我有一个 ShapeProcessor 抽象基类，它有一个纯虚拟方法，该方法强制用户提供一个捕获所有形状处理器并允许用户从 ShapeProcessor 派生并根据需要添加其他形状处理方法（例如 MyShapeProcessor : public ShapeProcessor）

观察

但是发现只有在 MyShapeProcessor 中为所有形状调用了 catch all 方法，而我的形状特定方法没有被调用。我需要做什么才能根据需要调用特定于形状的方法？警告：如果我将所有处理程序方法放在一个类中，它就可以正常工作。这是否意味着不能重载基类中的方法？我已阅读有关名称隐藏的帖子，但这似乎不适用于此处。或者是吗？我尝试使用“使用”取消隐藏基类方法，但似乎没有帮助。

下面是伪代码示例：

class Shape {
    virtual void processMe (ShapeProcessor * sp) {
        sp->processShape (*this);
}

// User derived shape
class Circle : public Shape {
    void processMe (ShapeProcessor * sp) {
        sp->processShape (*this);
}

// Base ShapeProcessor
class ShapeProcessor {
    virtual void processShape (Shape& shape) = 0; // User must provide a catch all method
}

// User provided shape processor
class MyShapeProcessor : public ShapeProcessor {
    void processShape (Circle& circle) {
       // Never gets called, even for Circle objects!
    }
    void processShape (Shape& shape) {
       // Always gets called for all shapes!
       cout << "Unsupported shape!" << endl;
    }
}

// User code
Circle * circle = new Circle();
MyShapeProcessor * sp = new MyShapeProcessor();
circle->processMe (sp);  

// Expecting processMe to eventually call MyShapeProcessor processShape (Circle) but calls processShape (Shape)

// Caveat: If I get rid of the ShapeProcessor base class and if I put all shape handles in a single class
// it works fine. Does this mean that it is not possible to overload methods in the base class? I have read
// the posts on name hiding, but that does not seem to apply here. Or does it?

Answer 1

你需要添加：

void processShape (Circle& circle);

到ShapeProcessor 作为virtual 成员函数。否则，任何processMe 函数都看不到此函数。

class ShapeProcessor {
    virtual void processShape (Shape& shape) = 0;

    virtual void processShape (Circle& circle) = 0;

};

当您在项目中添加Shape 的新子类型时，您必须返回ShapeProcessor 并为该子类型添加新的processShape 函数。

您可以使用模板来避免这种紧密耦合。看看https://stackoverflow.com/a/7877397/434551。

Answer 2

这种方法也适合你吗？

#include <iostream>


class Shape;


class ShapeProcessor {
public:
    virtual void processShape(Shape &shape){
        std::cout<<"Shape Processor";
    }
};

class CircleProcessor: public ShapeProcessor {

public:
    void processShape(Shape &shape)
    {
        std::cout<<"CircleProcessor";
    }
};
class  Shape
{
public:

    virtual void processMe(ShapeProcessor *sp){
        sp->processShape(*this);
    }
};
class Circle:public Shape
{
public:
    void processMe(ShapeProcessor *sp){
        sp->processShape(*this);
    }
};

int main(int argc, const char * argv[])
{
    Shape  *circle = new Circle();
    ShapeProcessor *sp = new CircleProcessor();
    circle->processMe(sp);
    return 0;
}