Cloning
We have seen the power of polymorphism through the use of base
class pointers. Polymorphism is fundamental to object oriented design.
This being the case, it is often the case that a class will contain
a pointer to a base class. When this occurs, making copies of that
class requires some care and the use of "cloning".
Let suppose Fred is a class that contains a pointer to a Shape
(our abstract base class) and that
Fred supports the usual operations -- constructor, destructor,
copy constructor and assignment operator.
<![CDATA[
class Fred
{
public:
Fred( );
~Fred( );
Fred( const Fred& fred);
Fred& operator= (const Fred& rhs);
// other public methods
private:
Shape *m_pShape;
// other private data members
};
]]>
If Fred is the "owner" of the object pointed to
(i.e. Fred is responsible for deleting the object),
care must now be taken when writing the copy constructor and
assignment operator. Why? Let's take a look. We know that we
need to perform a deep copy so that we don't have two different Fred objects
pointing to the same shape. We don't just want to copy
m_pShape from rhs, but we want to allocate our own memory and
copy the contents of *(rhs.m_pShape) into our newly allocated memory.
The problem is that we don't know if rhs.m_pShape is pointing to
a Circle, a Triangle, a Rectangle or some other kind of Shape.
Since that's the case, we don't know which derived class' copy constructor
to use. The solution is to define a pure virtual Clone( ) method
in the Shape class. This function is then called in the copy constructor
or assignment operator and polymorphism is used to call Clone()
for the appropriate derived class. Each derived class' Clone( ) returns a
pointer to a new dynamically allocated copy of itself using its own
copy constructor. In effect, Clone( ) is an indirect, polymorphic way to
copy a derived class that's pointed to by a base class pointer.
Here's some of the code.
<![CDATA[
// Fred's copy constructor
Fred::Fred (const Fred& rhs)
{
m_pShape = rhs.m_pShape->Clone( );
// code to handle the other data members
}
// define Clone( ) as pure virtual in Shape
class Shape
{
public:
virtual void Draw ( ) const = 0; // pure virtual method
virtual void Error ( ) const; // virtual method
void ObjectID ( ) const; // non-virtual method
// pure virtual Clone function
virtual Shape* Clone( ) const = 0;
};
// define Clone in Circle
class Circle : public Shape
{
public:
virtual void Draw( ) const; // method for drawing a circle
virtual void Error ( ) const; // overriding Shape::Error( )
virtual Circle* Clone( ) const;
};
// implement Clone in Circle
// This one line of code calls Circle's
// copy constructor
Circle* Circle::Clone( ) const
{
return new Circle( *this );
}
]]>
Implement Clone( ) in the same manner for all derived classes
Check out this webpage
for more example code and further discussion of cloning.
Dennis Frey
Last modified: Tue Nov 16 09:00:19 EST 2004