Copying a class that inherits from a class with pure virtual methods?


I've not used C++ in a while, and I've become far too comfortable with the ease-of-use of real languages.

At any rate, I'm attempting to implement the Command pattern, and I need to map a number of command object implementations to string keys. I have an STL map of string to Command, and I'd like to copy the Command.


Command * copiedCommand = new Command( commandImplementation );

And I'd like to retain the functionality of commandImplementation. Since Command has the pure virtual function execute, this doesn't work. What's the correct way to do this?


If Command is an abstract class, you won't be able to call the copy constructor directly. Instead, you might consider creating a clone() method that returns a deep copy of the object. This could also be a pure-virtual method that returns your base class, such as:

class Command {
        virtual Command* clone(void) const = 0;
By : jheddings

A prototype pattern is a creational design pattern used in software development when the type of objects to create is determined by a prototypical instance, which is cloned to produce new objects. This pattern is used to:

  • avoid subclasses of an object creator in the client application, like the abstract factory pattern does.
  • avoid the inherent cost of creating a new object in the standard way (e.g., using the 'new' keyword) when it is prohibitively expensive for a given application.

To implement the pattern, declare an abstract base class that specifies a pure virtual clone() method. Any class that needs a "polymorphic constructor" capability derives itself from the abstract base class, and implements the clone() operation.

The client, instead of writing code that invokes the "new" operator on a hard-coded class name, calls the clone() method on the prototype, calls a factory method with a parameter designating the particular concrete derived class desired, or invokes the clone() method through some mechanism provided by another design pattern.

By : NewbiZ

One way to do it would be to have add this to your Command class:

   virtual Command * Clone() const = 0;

... and then in the various subclasses of Command, implement Clone() to return a copy of the object:

   virtual Command * Clone() const {return new MyCommandSubclass(*this);}

Once that's done, you can then do what you want like this:

Command * copiedCommand = commandImplementation->Clone();

This video can help you solving your question :)
By: admin