How to Safely Downcast a `unique_ptr` to `unique_ptr` in C ?

Downcasting unique_ptr to unique_ptr

In the realm of object-oriented programming, inheritance plays a pivotal role in fostering code reuse and extensibility. However, situations may arise where one needs to "downcast" a unique_ptr object to a unique_ptr object, potentially with a different deleter function.

To address this challenge, consider a hypothetical scenario where an application employs several factories, each producing unique_ptr instances. These factories may internally offer access to various derived types, such as unique_ptr, unique_ptr, or unique_ptr. To illustrate:

unique_ptr<base> DerivedAFactory() {
    return unique_ptr<base>(new DerivedA);
}

The goal is to convert the pointer within the returned unique_ptr to a derived type, even if it differs from the original internal type. One can envision this process in pseudocode:

unique_ptr<derived> ptr = static_cast<unique_ptr>>(DerivedAFactory());</unique_ptr></derived>

However, this approach presents potential pitfalls. A more robust solution involves releasing the object from the unique_ptr, casting the raw pointer to the desired derived type, and reassigning it to a new unique_ptr with an appropriate deleter.

unique_ptr<derived> CastToDerived(Base* obj) {
    return unique_ptr<derived>(static_cast<derived>(obj));
}</derived></derived></derived>

This casting process should hold valid as long as the object is dynamically loaded from a DLL and released from the same context. However, when transferring ownership across different contexts, one must take care to supply a correct deleter alongside the pointer.

For added safety and flexibility, it is recommended to utilize function templates for casting:

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>

These templates ensure that the passed unique_ptr is not unintentionally stolen from the caller while providing both static and dynamic casting options. The static version can be employed when the pointer is known to be a Derived * without dynamic casting, while the dynamic version performs a runtime check using dynamic_cast.

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