ovga ovga - 1 month ago 6x
C++ Question

C++ destructor calling of boost::python wrapped objects

Does boost::python provide any guarantee when the C++ destructor of a
wrapped object is called considering the moment of reaching the zero
reference count of the corresponding python object?

I am concerned about a C++ object that opens a file for writing and performs the file closing in its destructor. Is it guaranteed that the file is written when all python references to the object are deleted or out of scope?

I mean:

del A # Is the C++ destructor of MyBoostPythonObject called here?

My experience suggests that the destructor is always called at this point but could not find any guarantee for this.


Boost.Python makes the guarantee that if the Python object has ownership of the wrapped C++ object, then when the Python object is deleted, the wrapped C++ object will be deleted. The Python object's lifetime is dictated by Python, wherein when an object’s reference count reaches zero, the object may be immediately destroyed. For non-simplistic cases, such as cyclic references, the objects will be managed by the garbage collector, and may be destroyed before the program exits.

One Pythonic solution may be to expose a type that implements the context manager protocol. The content manager protocol is made up of a pair of methods: one which will be invoked when entering a runtime context, and one which will be invoked when exiting a runtime context. By using a context manager, one could control the scope in which a file is open.

>>> with MyBoostPythonObject() as A:  # opens file.
...     A.write(...)                  # file remains open while in scope.
...                                   # A destroyed once context's scope is exited.

Here is an example demonstrating exposing a RAII-type class to Python as a context manager:

#include <boost/python.hpp>
#include <iostream>

// Legacy API.
struct spam
  spam(int x)    { std::cout << "spam(): " << x << std::endl;   }
  ~spam()        { std::cout << "~spam()" << std::endl;         }
  void perform() { std::cout << "spam::perform()" << std::endl; }

/// @brief Python Context Manager for the Spam class.
class spam_context_manager

  spam_context_manager(int x): x_(x) {}

  void perform() { return impl_->perform(); }

// context manager protocol

  // Use a static member function to get a handle to the self Python
  // object.
  static boost::python::object enter(boost::python::object self)
    namespace python = boost::python;
    spam_context_manager& myself =

    // Construct the RAII object.
    myself.impl_ = std::make_shared<spam>(myself.x_);

    // Return this object, allowing caller to invoke other
    // methods exposed on this class.
    return self;

  bool exit(boost::python::object type,
            boost::python::object value,
            boost::python::object traceback)
    // Destroy the RAII object.
    return false; // Do not suppress the exception.
  std::shared_ptr<spam> impl_;
  int x_;

  namespace python = boost::python;
  python::class_<spam_context_manager>("Spam", python::init<int>())
    .def("perform", &spam_context_manager::perform)
    .def("__enter__", &spam_context_manager::enter)
    .def("__exit__", &spam_context_manager::exit)

Interactive usage:

>>> import example
>>> with example.Spam(42) as spam:
...     spam.perform()
spam(): 42