How to Safely Downcast a `unique_ptr` from Base to Derived in C ?

How to Downcast a unique_ptr from Base to Derived

In object-oriented programming, it is common to use class hierarchies to represent real-world concepts. In C , this is often done using inheritance. Inheritance allows a derived class to inherit the properties and behavior of its base class.

One common need when working with class hierarchies is to convert a pointer to a base class into a pointer to a derived class. This process is known as downcasting.

In the context of unique pointers, downcasting can be a bit tricky. This is because unique pointers are designed to prevent dangling pointers and other memory issues. As a result, you cannot simply use a static_cast to convert a unique_ptr to a different type.

Instead, you must use one of the following methods:

1. Static Unique Pointer Cast

This method can be used when you are certain that the unique pointer actually contains a pointer to a derived class. The following function template can be used to perform a static unique pointer cast:

template<typename derived typename base 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()));
}</derived></derived></derived></typename>

2. Dynamic Unique Pointer Cast

This method can be used when you are not certain that the unique pointer contains a pointer to a derived class. The following function template can be used to perform a dynamic unique pointer cast:

template<typename derived typename base 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());
}</derived></derived></derived></derived></typename>

Example

The following code demonstrates how to use the static unique pointer cast to convert a unique_ptr to a different type:

#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;
}</derived></derived></derived></memory>

In this example, we create a unique_ptr to a Base object. We then use the static unique pointer cast to convert the unique_ptr to a unique_ptr to a Derived object. This is possible because we know that the unique_ptr to the Base object actually contains a pointer to a Derived object.

The above is the detailed content of How to Safely Downcast a `unique_ptr` from Base to Derived in C ?. For more information, please follow other related articles on the PHP Chinese website!