多态性的良好实践

Question

Suppose a Domain which stores a pointer to Shape . The exact shape ( Triangle or Rectangle ) is not known at compile time and would be clear after reading input. At run-time I might need to access variables of derived structures but this is not possible because the pointer points to the base structure. I found another solution which is to do "switch-on-type" but it is discouraged as pointed out in the answer here . He also said that

When you use polymorphism, you shouldn't need to care about what's behind a base class reference/pointer.

Well in this case I do care so it sounds like I should not use polymorphism. I guess what I do below is a bad design but then what is a good design to solve this problem?

struct Shape
{
    int common_variable;
};

struct Triangle: Shape
{
    int triangle_specific_variable;
};

struct Rectangle: Shape
{
    int rectangle_specific_variable;
};

struct Domain
{
    Shape* shape;
};

int main()
{
    Domain domain;
    //domain.shape = new Triangle(); // depends on input.
    //domain.shape = new Rectangle(); // depends on input.

    return 0;
}

Answer 1

Your question clearly shows need for polymorphism, as you want to work with triangles, rechtangles, etc. and you know that all these are shapes.

Why is t not advised to access specific data using a switch ?

Because this is exactly the contrary of a polymorphic design. Instead of working with shapes, drawing them, calculating their area, etc... you always need to know the type of the shape and code specific behavior.

Imagine that you've finished your code, and then you discover that you want also squares and circles: what a nightmare it would be to maintain this.

How to solve this ?

You have to abstract from the concrete classes and define the general operations that you could perform on general shapes. Then define these operations as virtual functions, and in your code using Domain, just call the virtual functions.

To genralize further, instead of creating objects from the class, you could use a factory method that returns a shape from a stream for example.

Example:

class Shape
{
public: 
    virtual void scale(double scale_factor)=0; 
    virtual void rotate(double angle)=0; 
    virtual void draw(window w)=0; 
    virtual Shape* clone()=0; 
    virtual ~Shape() {}
}; 

class Triangle: public Shape
{
    Point A, B, C; 
public: 
    Triangle (Point a,Point b, Point c) : A(a), B(b), C(c) { }
    void scale(double scale_factor) override; 
    void rotate(double angle) override; 
    void draw(window w) override; 
    Shape* clone() { return new Triangle(*this); }      
};

...

int main()
{
    Domain domain, domain2;
    Window wnd = CreateWindow(...);  // depends on your GUI library
    Point a,b,c; 
    cin >> a >> b >> c; 
    domain.shape = new Triangle(a,b,c); 

    // Once the object is constructed no need to know the details of the shape here
    domain.shape->rotate(45); 
    domain2.shape = domain.shape->clone(); 
    domain.shape->draw(wnd); 
    ...
    return 0;
}

Note that working with smart pointers would be safer than with raw pointers;

Answer 2

First. Polymorphism is almost always only the right tool for the job when the concrete objects have exactly the same interface.

Second, that's rarely the case and sometimes polymorphism is a better fit than a variant.

In such a situation, we defer the behaviour to the implementation rather than try to deduce it from outside the object.

One way to do this is the 'visitor pattern':

struct triangly_thing { int i; };
struct rectangly_thing { int i; };

struct shape_visitor
{
    virtual void operator()(triangly_thing thing) const
    {
        // do triangly things
    }

    virtual void operator()(rectangly_thing thing) const
    {
        // do rectangly things
    }
};

struct Shape
{
    int common_variable;

    virtual void visit(shape_visitor const& visitor)
    {

    }
};


struct Triangle: Shape
{
    triangly_thing my_triangly_thing;

    void visit(shape_visitor const& visitor) override
    {
        visitor(my_triangly_thing);
    }
};

struct Rectangle: Shape
{
    rectangly_thing my_rectangly_thing;

    void visit(shape_visitor const& visitor) override
    {
        visitor(my_rectangly_thing);
    }
};

struct Domain
{
    Shape* shape;
};

int main()
{
    Domain domain;

    struct my_shape_visitor_type : shape_visitor
    {
        // customise overrides in here
    } my_shape_visitor;

    domain.shape->visit(my_shape_visitor);

    return 0;
}