Home / Questions / 67099
Accepted
eferion
Asked: 2020-05-04 07:00:11 +0800 CST 2020-05-04 07:00:11 +0800 CST

Conversion between smart pointers

  • 772

Suppose we have the following classes:

struct A
{
  virtual ~A() = default;
};

struct B : A
{ };

In addition, we have a factory function that returns generic smart pointers of type A:

std::shared_ptr<A> FuncionFactoria(int n)
{
  if( n % 2 )
    return std::make_shared<A>();
  else
    return std::make_shared<B>();
}

And on the other hand, we have a couple of functions. One supports a smart pointer of type A and the other a smart pointer of type B:

void FuncionGenerica(std::shared_ptr<A>);
void FuncionEspecifica(std::shared_ptr<B>);

How could one perform a safe conversion between pointers? A possible example of use:

int main()
{
  for( int i=0; i<10; i++ )
  {
    std::shared_ptr<A> aSptr = FuncionFactoria(i);
    std::shared_ptr<B> bSptr = /* ¿¿¿??? */
    if( bSptr )
      FuncionEspecifica(bSptr);

    FuncionGenerica(aSptr);
  }
}

Note that pointers of type A must be valid after conversion...

c++

1 Answers

  1. Best Answer

    The smart pointer transformation tools provided by the standard library should suffice :

    • std::shared_ptr<T> static_pointer_cast( const std::shared_ptr<U>& r );the equivalent to static_castwith other data types.
    • std::shared_ptr<T> dynamic_pointer_cast( const std::shared_ptr<U>& r );the equivalent to dynamic_castwith other data types.
    • std::shared_ptr<T> const_pointer_cast( const std::shared_ptr<U>& r );the equivalent to const_castwith other data types.
    • std::shared_ptr<T> reinterpret_pointer_cast( const std::shared_ptr<U>& r );the equivalent to reinterpret_castwith other data types.

    All of these conversions are available through the header <memory>which, if you're using smart pointers, you'll need to have included at some point.

    If we look at implementation 1 of smart pointer conversion, we can see that std::static_pointer_castit behaves like this:

    template< class T, class U > 
std::shared_ptr<T> static_pointer_cast( const std::shared_ptr<U>& r ) noexcept
{
    auto p = static_cast<typename std::shared_ptr<T>::element_type*>(r.get());
    return std::shared_ptr<T>(r, p);
}

    According to the documentation available in cppreference it is using the eighth constructor whose details are:

    Construct a shared_ptrthat shares property information with rbut stores a ptrnon-self-managed, unrelated pointer. Even if this shared_ptris the last of a group to leave the scope, the destructor of the object originally self-managed by will be called r. However, calling will get()always return a copy of ptr. It is the programmer's responsibility to ensure that it ptrremains valid as long as it shared_ptrexists.

    So, in your case it can be used std::static_pointer_castin your code without affecting its security:

    std::shared_ptr<A> FuncionFactoria(int n)
{
    if( n % 2 )
        return std::make_shared<A>();
    else
        return std::static_pointer_cast<A>(std::make_shared<B>());
        //     ^-------- Transformamos el puntero inteligente
}

int main()
{
    for( int i=0; i<10; i++ )
    {
        std::shared_ptr<A> aSptr = FuncionFactoria(i);
        std::shared_ptr<B> bSptr = std::static_pointer_cast<B>(FuncionFactoria(i));
        //                         ^-------- Transformamos el puntero inteligente

        if( bSptr )
            FuncionEspecifica(bSptr);

        FuncionGenerica(aSptr);
    }

    return 0;
}

    1 The exact implementation will vary between compilers, but the C++ standard guarantees that behavior will be the same regardless of implementation details.

    • 4