...
In this noncompliant code example, the poly
pointer value owned by a std::shared_ptr
object is cast to the D *
pointer type with dynamic_cast()
in an attempt to obtain a std::shared_ptr
of the polymorphic derived type. However, this eventually results in undefined behavior as the same pointer is thereby stored in two different std::shared_ptr
objects. When g()
exits, the pointer stored in derived
is freed by the default deleter. Any further use of poly
results in accessing freed memory. When f()
exits, the same pointer stored in poly
is destroyed, resulting in a double-free vulnerability.
...
In this compliant solution, the dynamic_cast()
is replaced with a call to std::dynamic_pointer_cast()
, which returns a std::shared_ptr
of the polymorphic type with the valid shared pointer value. When g()
exits, the reference count to the underlying pointer is decremented by the destruction of derived
, but because of the reference held by poly
(within f()
), the stored pointer value is still valid after g()
returns.
...