Re: Solving the data inheritance problem
Excuse me, but I don't see how you can support swap for this.
What happens if I do:
Circle c( ... ) ;
Square s( ... ) ;
c.swap( s ) ;
Ditto assignment. Normally, in a polymorphic hierarchy, the
base class declares (but doesn't define) a private operator=,
and we don't think any more about it.
Example:
class A
{
protected:
// We don't want to make this public
// so that the user can't cause
// slicing type accidents (same applies
// to copy constructor and assignment)
void swap(A& that)
{
std::swap(data_, that.data_);
}
private:
int data_;
};
class B
: public A
{
public:
void swap(B& that)
{
A::swap(that);
std::swap(furtherData_, that.furtherData_);
}
private:
int furtherData_;
};
I'm also not too sure about the control points. I'm rather
sceptical that all possible shapes have exactly two control
points, for example. And the semantics of the control points
varies according to the shape: it's the center for Circle, but
one of the corners for Square, for example. Before pronouncing
futher, I'd want to see some concrete use cases. But I think if
you start forcing exactly two control points, etc. you're moving
toward the template method pattern, and that's probably what you
should be using.
A Shape can have an arbitrary number of control points and it can be
used to move them around without the need to know anything about the
subclass. Here's a more detailed example (only important pieces given):
class Shape
{
public:
// This way the user can control the points movement.
const Point& getPoint(int pointId);
void setPoint(int pointId, const Point& that);
// This way the user gets a list of the control points
// available.
void getPoints(std:vector<int>& ids);
virtual void draw() const = 0;
protected:
// This interface is only available to derived classes
void swap(Shape& that)
{
points_.swap(that.points_);
}
// The creation returns a handle to the created point.
int createPoint();
void removePoint(int pointId);
private:
// Here we actually store the points.
std::map<int, Point> points_;
};
class Triangle
: public Shape
{
public:
Triangle()
: aPointId_(createPoint())
, bPointId_(createPoint())
, cPointId_(createPoint())
{
}
void swap(Triangle& that)
{
Shape::swap(that);
std::swap(aPointId_);
std::swap(bPointId_);
std::swap(cPointId_);
}
virtual void draw() const
{
const Point& a = getPoint(aPointId_);
const Point& b = getPoint(bPointId_);
const Point& c = getPoint(cPointId_);
// Draw the triangle formed by abc.
}
private:
int aPointId_;
int bPointId_;
int cPointId_;
};
--
Kalle Rutanen
http://kaba.hilvi.org
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]