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

Question

What I am trying to do

I am converting an existing code base which uses dynamic_casting to identify the derived class (shape) to apply derived class specific processing, to a scheme which is based on the visitor pattern. To this effect, I have added a processMe method to the base class (virtual) and in each derived class and a handleShape method to a ShapeProcessor class, one for each type of shape to be processed, typical of the visitor pattern. I have a ShapeProcessor abstract base class that has one pure virtual method that forces the user to provide a catch all shape processor and allows the user to derive from the ShapeProcessor and add other shape processing methods as desired (eg MyShapeProcessor : public ShapeProcessor)

Observation

However what find is that only the catch all method gets called in MyShapeProcessor for all shapes, my shape specific methods are not getting called. What do I need to do to get the shape specific methods to get called as desired? Caveat: If I put all handler methods in one 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? I tried to unhide the base class method using "using" but does not seem to help.

Here is the pseudo code example:

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

You need to add:

void processShape (Circle& circle);

to ShapeProcessor as a virtual member function. Without that, this function is not visible from any of the processMe functions.

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

    virtual void processShape (Circle& circle) = 0;

};

When you add a new sub-type of Shape in your project, you have to come back to ShapeProcessor and add a new processShape function for the sub-type.

You can use templates to avoid some of this tight coupling. Take a look at https://stackoverflow.com/a/7877397/434551 .

Answer 2

Would this approach also suit you??

#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;
}