Wie kann man in C einen „unique_ptr' sicher von der Basis auf eine abgeleitete Version umwandeln?

So Downcasting eines unique_ptr von Base zu Abgeleitet

In der objektorientierten Programmierung ist es üblich, Klassenhierarchien zu verwenden, um reale Objekte darzustellen. Weltkonzepte. In C erfolgt dies häufig über Vererbung. Durch Vererbung kann eine abgeleitete Klasse die Eigenschaften und das Verhalten ihrer Basisklasse erben.

Eine häufige Anforderung bei der Arbeit mit Klassenhierarchien besteht darin, einen Zeiger auf eine Basisklasse in einen Zeiger auf eine abgeleitete Klasse umzuwandeln. Dieser Vorgang wird als Downcasting bezeichnet.

Im Zusammenhang mit eindeutigen Zeigern kann Downcasting etwas knifflig sein. Dies liegt daran, dass eindeutige Zeiger darauf ausgelegt sind, baumelnde Zeiger und andere Speicherprobleme zu verhindern. Daher können Sie nicht einfach einen static_cast verwenden, um einen unique_ptr in einen anderen Typ zu konvertieren.

Stattdessen müssen Sie eine der folgenden Methoden verwenden:

1. Statische Umwandlung eindeutiger Zeiger

Diese Methode kann verwendet werden, wenn Sie sicher sind, dass der eindeutige Zeiger tatsächlich einen Zeiger auf eine abgeleitete Klasse enthält. Die folgende Funktionsvorlage kann verwendet werden, um eine statische eindeutige Zeigerumwandlung durchzuführen:

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. Dynamische Umwandlung eindeutiger Zeiger

Diese Methode kann verwendet werden, wenn Sie nicht sicher sind, ob der eindeutige Zeiger einen Zeiger auf eine abgeleitete Klasse enthält. Die folgende Funktionsvorlage kann verwendet werden, um eine dynamische Umwandlung eines eindeutigen Zeigers durchzuführen:

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());
}

Beispiel

Der folgende Code zeigt, wie die statische Umwandlung eines eindeutigen Zeigers verwendet wird Konvertieren Sie einen unique_ptr in einen anderen Typ:

#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;
}

In diesem Beispiel erstellen wir einen unique_ptr in ein Basisobjekt. Anschließend verwenden wir die Umwandlung des statischen eindeutigen Zeigers, um den unique_ptr in einen unique_ptr in ein abgeleitetes Objekt umzuwandeln. Dies ist möglich, weil wir wissen, dass der unique_ptr des Basisobjekts tatsächlich einen Zeiger auf ein abgeleitetes Objekt enthält.

Das obige ist der detaillierte Inhalt vonWie kann man in C einen „unique_ptr' sicher von der Basis auf eine abgeleitete Version umwandeln?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!