Interface to modify an abstract attribute - c++

Question

class AbstractShape;
class RectangularShape : public AbstractShape
{
void setWidth(double v);
void setLength(double v);
};
class CircleShape : public AbstractShape
{
void setRadius(double v);
};
class PolygonalShape : public AbstractShape
{
void addPoint(Point p);
};
class Element
{
protected:
AbstractShape* _shape; //RectangularShape, PolygonalShape or CircleShape
};
I want to create methods in Element to modify the shape _shape of Element ( ie if the shape is Rectangular I have to be able to change the length and the width, otherwise I have to be able to add a Point to the polygonal shape etc ).
For instance I cannot declare a setLength method because setLength as only a meaning if _shape is a RectangularShape. A solution would be to subclass Element in RectangularElement, PolygonalElement, CircularElement but I would like to avoid this solution.
Do you see another way to do that ?

Answer 1

May be you could do something like following :
class Shape
{
// ....
virtual void setWidth(double v) { /* not implemented, throw error ? */ }
virtual void setLength(double v){ /* not implemented, throw error ? */}
virtual void setRadius(double v){ /* not implemented, throw error ? */}
virtual void addPoint(Point p) { /* not implemented, throw error ? */}
//....
};
class RectangularShape : public Shape
{
void setWidth(double v) override ;
void setLength(double v) override;
};
class CircleShape : public Shape
{
void setRadius(double v) override ;
};
class PolygonalShape : public Shape
{
void addPoint(Point p) override;
};
class Element
{
protected:
Shape* _shape; //Any shape
};
Calling meaningless function on a _shape will print a message or assert .

Answer 2

Other than basic fat interface implementation I mentioned, if you don't want to pollute your abstract base class for whatever reason, one possible solution is to use a fat interface on another class and capability queries
class AbstractShape {};
class RectangularShape : public AbstractShape
{
public:
void setWidth(double v);
void setLength(double v);
};
class CircleShape : public AbstractShape
{
public:
void setRadius(double v);
};
class PolygonalShape : public AbstractShape
{
public:
void addPoint(Point p);
};
class Element {
public:
void setWidth(double);
void setLength(double);
void setRadius(double);
void addPoint(Point);
protected:
std::unique_ptr<AbstractShape> shape;
};
And the implementation of setWidth() for example could look like this
void Element::setWidth(double val) {
if (auto rectangle = dynamic_cast<Rectangle*>(this->shape.get())) {
rectangle->setWidth(val);
} else {
throw std::runtime_error{"This type does not implement setWidth()"};
}
}
Also note that you probably want to use a std::unique_ptr and not a raw pointer.