How to Create Derived Class Instances from Polymorphic Base Class Pointers?

Creating Derived Class Instances from Polymorphic Base Class Pointers

In object-oriented programming, it is often necessary to copy or create instances of derived classes from pointers to polymorphic base classes. However, this operation can be challenging when multiple derived types exist.

The naive approach of using multiple typeids or dynamic_casts in if-statements to check for each type and then using new is inefficient and error-prone. A better solution is to use a virtual method in the base class to create a copy.

Virtual clone() Method

By defining a virtual clone() method in the base class and implementing it in each derived class, it is possible to dynamically create a copy of the derived class instance. The clone() method should return a pointer to the newly created copy.

<code class="cpp">class Base {
  virtual ~Base();
  // Returns a dynamically created copy of this object
  virtual Base* clone() const = 0;
};</code>

<code class="cpp">class Derived1 : public Base {
  // Implements the clone() method for Derived1
  virtual Base* clone() const {
    return new Derived1(*this);
  }
};</code>

<code class="cpp">class Derived2 : public Base {
  // Implements the clone() method for Derived2
  virtual Base* clone() const {
    return new Derived2(*this);
  }
};</code>

Using this approach, you can create a copy of a derived class instance from a base class pointer as follows:

<code class="cpp">Base* basePtr = new Derived1();
Base* copyPtr = basePtr->clone();</code>

CRTP Idiom for Minimalist Implementation

To avoid duplicating the code for implementing the clone() method in each derived class, you can use the Curiously Recurring Template Pattern (CRTP) idiom:

<code class="cpp">template <class derived>
class DerivationHelper : public Base {
public:
  virtual Base* clone() const {
    return new Derived(static_cast<const derived>(*this));
  }
};</const></class></code>

<code class="cpp">class Derived1 : public DerivationHelper<derived1> {
  // Other members...
};</derived1></code>

<code class="cpp">class Derived2 : public DerivationHelper<derived2> {
  // Other members...
};</derived2></code>

This approach automatically implements the clone() method in each derived class while ensuring that the copy constructor is called for the correct type.

The above is the detailed content of How to Create Derived Class Instances from Polymorphic Base Class Pointers?. For more information, please follow other related articles on the PHP Chinese website!