Comment downcast en toute sécurité un `unique_ptr` de base vers dérivé en C ?

Comment downcaster un unique_ptr de base en dérivé

Dans la programmation orientée objet, il est courant d'utiliser des hiérarchies de classes pour représenter des objets réels. notions du monde. En C , cela se fait souvent en utilisant l'héritage. L'héritage permet à une classe dérivée d'hériter des propriétés et du comportement de sa classe de base.

Un besoin courant lorsque l'on travaille avec des hiérarchies de classes est de convertir un pointeur vers une classe de base en un pointeur vers une classe dérivée. Ce processus est connu sous le nom de downcasting.

Dans le contexte de pointeurs uniques, le downcasting peut être un peu délicat. En effet, les pointeurs uniques sont conçus pour éviter les pointeurs suspendus et autres problèmes de mémoire. Par conséquent, vous ne pouvez pas simplement utiliser un static_cast pour convertir un unique_ptr en un type différent.

Au lieu de cela, vous devez utiliser l'une des méthodes suivantes :

1. Static Unique Pointer Cast

Cette méthode peut être utilisée lorsque vous êtes certain que le pointeur unique contient réellement un pointeur vers une classe dérivée. Le modèle de fonction suivant peut être utilisé pour effectuer une conversion de pointeur unique statique :

template<typename Derived, typename Base, typename Del>
std::unique_ptr<Derived, Del>
static_unique_ptr_cast(std::unique_ptr<Base, Del> &&p) {
  auto d = static_cast<Derived *>(p.release());
  return std::unique_ptr<Derived, Del>(d, std::move(p.get_deleter()));
}

2. Dynamic Unique Pointer Cast

Cette méthode peut être utilisée lorsque vous n'êtes pas certain que le pointeur unique contient un pointeur vers une classe dérivée. Le modèle de fonction suivant peut être utilisé pour effectuer une conversion de pointeur unique dynamique :

template<typename Derived, typename Base, typename Del>
std::unique_ptr<Derived, Del>
dynamic_unique_ptr_cast(std::unique_ptr<Base, Del> &&p) {
  if (Derived *result = dynamic_cast<Derived *>(p.get())) {
    p.release();
    return std::unique_ptr<Derived, Del>(result, std::move(p.get_deleter()));
  }
  return std::unique_ptr<Derived, Del>(nullptr, p.get_deleter());
}

Exemple

Le code suivant montre comment utiliser la conversion de pointeur unique statique pour convertir un unique_ptr en un type différent :

#include <memory>

class Base {
public:
  virtual ~Base() {}
};

class Derived : public Base {
public:
  ~Derived() {}
};

int main() {
  std::unique_ptr<Base> uptr = std::make_unique<Derived>();
  std::unique_ptr<Derived> dptr = static_unique_ptr_cast<Derived>(std::move(uptr));
  return 0;
}

Dans cet exemple, nous créons un unique_ptr en un objet de base. Nous utilisons ensuite le cast de pointeur unique statique pour convertir le unique_ptr en unique_ptr en un objet Derived. Ceci est possible car nous savons que le unique_ptr de l'objet Base contient en fait un pointeur vers un objet Derived.

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!