Comment créer des instances de classe dérivées à partir de pointeurs de classe de base polymorphes ?

Création d'instances de classe dérivées à partir de pointeurs de classe de base polymorphes

En programmation orientée objet, il est souvent nécessaire de copier ou de créer des instances de classes dérivées classes allant des pointeurs aux classes de base polymorphes. Cependant, cette opération peut être difficile lorsque plusieurs types dérivés existent.

L'approche naïve consistant à utiliser plusieurs typeids ou Dynamic_casts dans les instructions if pour vérifier chaque type, puis à utiliser new est inefficace et sujette aux erreurs. Une meilleure solution consiste à utiliser une méthode virtuelle dans la classe de base pour créer une copie.

Méthode Virtual clone()

En définissant un clone( ) dans la classe de base et en l'implémentant dans chaque classe dérivée, il est possible de créer dynamiquement une copie de l'instance de classe dérivée. La méthode clone() doit renvoyer un pointeur vers la copie nouvellement créée.

<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>

En utilisant cette approche, vous pouvez créer une copie d'une instance de classe dérivée à partir d'un pointeur de classe de base comme suit :

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

Idiome CRTP pour une implémentation minimaliste

Pour éviter de dupliquer le code d'implémentation du clone() dans chaque classe dérivée, vous pouvez utiliser l'idiome CRTP (Curiously Recurring Template Pattern) :

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

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

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

Cette approche implémente automatiquement la méthode clone() dans chaque classe dérivée tout en garantissant que le constructeur de copie est appelé pour le type correct.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!