How can I safely downcast a `unique_ptr` to a `unique_ptr` in C ?

Downcasting unique_ptr to unique_ptr

Introduction:

In $texttt{C }$ programming, we may encounter scenarios where we need to convert or "downcast" a $texttt{unique_ptr}$ of a base class $texttt{Base}$ to a $texttt{unique_ptr}$ of a derived class $texttt{Derived}$. This process involves casting the raw pointer stored within the $texttt{unique_ptr}$ to the desired derived type while maintaining ownership semantics.

Casting via Releasing and Reassigning:

The question proposes a method of releasing the object from the $texttt{unique_ptr}$ and then casting the raw pointer to the desired derived type. This approach is conceptually valid, but it has a potential drawback: the object's lifetime is momentarily managed by a raw pointer, which could lead to memory leaks if the caller fails to properly handle the $texttt{unique_ptr}$ afterwards.

Alternative: Static and Dynamic Unique Pointer Casting:

To address this issue, we can leverage the following function templates:

• $texttt{static_unique_ptr_cast}$: Performs static casting, assuming the raw pointer is guaranteed to be of the desired derived type.
• $texttt{dynamic_unique_ptr_cast}$: Performs dynamic casting, using $texttt{dynamic_cast}$ to verify the cast's validity.

Implementation:

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

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></derived></derived></derived></typename>

Usage:

Use $texttt{static_unique_ptr_cast}$ when you're certain about the derived type. Otherwise, use $texttt{dynamic_unique_ptr_cast}$ to check for the correct type at runtime. These functions employ rvalue references to prevent unintentional modifications to the original $texttt{unique_ptr}$.

The above is the detailed content of How can I safely downcast a `unique_ptr` to a `unique_ptr` in C ?. For more information, please follow other related articles on the PHP Chinese website!