Staw man solution to pybind#1546

Author: cdyson37

docs/changelog.rst

@@ -50,6 +50,9 @@ v2.3.0 (Not yet released)
 * ``pybind11/stl.h`` does not convert strings to ``vector<string>`` anymore.
   `#1258 <https://github.com/pybind/pybind11/issues/1258>`_.
 
+* fixed shared_ptrs to Python-derived instances outliving the associated Python object
+  `#1546 <https://github.com/pybind/pybind11/issues/1546>`_.
+
 v2.2.4 (September 11, 2018)
 -----------------------------------------------------
 

include/pybind11/cast.h

@@ -1496,9 +1496,46 @@ struct copyable_holder_caster : public type_caster_base<type> {
     holder_type holder;
 };
 
-/// Specialize for the common std::shared_ptr, so users don't need to
+/// Specialize type_caster for std::shared_ptr<T>.
+/// This is the same as copyable_holder_caster, except that when casting to C++
+/// we keep the Python object alive through the shared_ptr as e.g. virtual
+/// functions and derived state might be defined there.
 template <typename T>
-class type_caster<std::shared_ptr<T>> : public copyable_holder_caster<T, std::shared_ptr<T>> { };
+class type_caster<std::shared_ptr<T>>
+{
+    PYBIND11_TYPE_CASTER (std::shared_ptr<T>, _(PYBIND11_STRING_NAME));
+
+    // Re-use copyable_holder_caster
+    using BaseCaster = copyable_holder_caster<T, std::shared_ptr<T>>;
+
+    bool load (pybind11::handle src, bool b)
+    {
+        BaseCaster bc;
+        bool success = bc.load (src, b);
+        if (!success)
+        {
+            return false;
+        }
+
+        // * Get src as a py::object
+        // * Construct a shared_ptr to the py::object
+        auto py_obj = reinterpret_borrow<object> (src);
+        auto py_obj_ptr = std::make_shared<object> (py_obj);
+
+        // * Use BaseCaster to get it as the shared_ptr<T>
+        // * Use this to make an aliased shared_ptr<T> that keeps the py::object alive
+        auto base_ptr = static_cast<std::shared_ptr<T>> (bc);
+        value = std::shared_ptr<T> (py_obj_ptr, base_ptr.get ());
+        return true;
+    }
+
+    static handle cast (std::shared_ptr<T> sp,
+                        return_value_policy rvp,
+                        handle h)
+    {
+        return BaseCaster::cast (sp, rvp, h);
+    }
+};
 
 template <typename type, typename holder_type>
 struct move_only_holder_caster {
@@ -1540,6 +1577,9 @@ template <typename base, typename holder> struct is_holder_type :
 template <typename base, typename deleter> struct is_holder_type<base, std::unique_ptr<base, deleter>> :
     std::true_type {};
 
+template <typename T>
+struct is_holder_type<T, std::shared_ptr<T>> : std::true_type {};
+
 template <typename T> struct handle_type_name { static constexpr auto name = _<T>(); };
 template <> struct handle_type_name<bytes> { static constexpr auto name = _(PYBIND11_BYTES_NAME); };
 template <> struct handle_type_name<args> { static constexpr auto name = _("*args"); };

tests/test_virtual_functions.py

@@ -388,5 +388,7 @@ def f(self, value):
             print("Right one", 42)
 
     holder = m.SharedPtrHolder(Derived())
+    # At this point, our 'Derived' instance has gone out of scope in Python but
+    # is being kept alive by a shared_ptr inside 'holder'.
     holder.run(42);
     assert somelist == [42]