Хранение значения, созданного на python, в статическом бусте в C ++ :: shared_ptr

У вас проблема в том, что уничтожение shared_ptr происходит после завершения работы python. Смотреть на:

• shared_ptr_from_python.hpp
• shared_ptr_deleter
• http://docs.python.org/2/c-api/sys.html#Py_AtExit).

Я предлагаю инкапсулировать shared_ptr, который поставляется без дополнительного кода очистки.
Хотя четыре душа:

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

struct A {
std::string _a;
A(std::string a): _a(a) {}
~A() { std::cout << "Destruct: " << _a << std::endl; }
std::string str() { return _a; }
};

void python_exit();

static boost::shared_ptr<A> holder(new A("foo"));

static boost::shared_ptr<A> get_holder() {
return holder;
}

static void set_holder(boost::shared_ptr<A> a_ptr) {
// The shared_ptr comes with python::converter::shared_ptr_deleter
holder = a_ptr;
}// Fix 1: Cleanup while python is running
// ======================================

void reset_holder() {
std::cout << "reset" << std::endl;
holder.reset(new A("holder without shared_ptr_deleter"));
}// Fix 2: The shared pointer is never deleted (which is a memory leak of a
//        global varialbe). The contained object is destructed, below.
// =========================================================================

static boost::shared_ptr<A>* holder_ptr = new boost::shared_ptr<A>(
new A("foo_ptr"));

static boost::shared_ptr<A> get_holder_ptr() {
return *holder_ptr;
}

static void set_holder_ptr(boost::shared_ptr<A> a_ptr) {
// Note: I know, it's no good to do that here (quick and dirty):
Py_AtExit(python_exit);
// The shared_ptr comes with python::converter::shared_ptr_deleter
*holder_ptr = a_ptr;
}

void python_exit() {
std::cout << "\n""Since Python’s internal finalization will have completed before the\n""cleanup function, no Python APIs should be called in or after exit.\n""The boost::python::shared_ptr_deleter will do so, though.\n"<< std::endl;
// Destruction but no deallocation.
holder_ptr->get()->~A();
}// Fix 3: Put a finalizer object into a module.
// =========================================================================

static boost::shared_ptr<A> holder_finalizer(new A("foo_finalizer"));struct PythonModuleFinalizer
{
~PythonModuleFinalizer();
};

PythonModuleFinalizer::~PythonModuleFinalizer() {
std::cout << "PythonModuleFinalizer" << std::endl;
holder_finalizer.reset(
new A("holder_finalizer without shared_ptr_deleter"));
}

static boost::shared_ptr<A> get_holder_finalizer() {
return holder_finalizer;
}

static void set_holder_finalizer(boost::shared_ptr<A> a_ptr) {
// The shared_ptr comes with python::converter::shared_ptr_deleter
holder_finalizer = a_ptr;
}// Fix 4: Encapsulate the shared_ptr
// =========================================================================

class B {
private:
struct I {
std::string b;
I(const std::string& b): b(b) {}
~I() { std::cout << "Destruct: " << b << std::endl; }
};

public:
B(std::string b): s(new I(b)) {}
std::string str() { return s.get()->b; }

private:
boost::shared_ptr<I> s;
};

static B holder_encapsulate("foo_encapsulate");static B get_holder_encapsulate() {
return holder_encapsulate;
}

static void set_holder_encapsulate(B b) {
holder_encapsulate = b;
}BOOST_PYTHON_MODULE(test)
{
using namespace boost::python;

class_<A, boost::shared_ptr<A> >("A", init<std::string>())
.def("__str__", &A::str)
;

def("set_holder", &set_holder);
def("get_holder", &get_holder);
def("reset_holder", &reset_holder);

def("set_holder_ptr", &set_holder_ptr);
def("get_holder_ptr", &get_holder_ptr);

object finalizer_class = class_<PythonModuleFinalizer
("PythonModuleFinalizer", init<>());
object finalizer = finalizer_class();
scope().attr("ModuleFinalizer") = finalizer;
def("set_holder_finalizer", &set_holder_finalizer);
def("get_holder_finalizer", &get_holder_finalizer);

class_<B>("B", init<std::string>())
.def("__str__", &B::str)
;
def("set_holder_encapsulate", &set_holder_encapsulate);
def("get_holder_encapsulate", &get_holder_encapsulate);

}

Файл Python:

import test
print(str(test.get_holder()))
test.set_holder(test.A('bar'))
print(str(test.get_holder()))
test.reset_holder()

print(str(test.get_holder_ptr()))
test.set_holder_ptr(test.A('bar_ptr'))
print(str(test.get_holder_ptr()))

print(str(test.get_holder_finalizer()))
test.set_holder_finalizer(test.A('bar_finalizer'))
print(str(test.get_holder_finalizer()))

print(str(test.get_holder_encapsulate()))
test.set_holder_encapsulate(test.B('bar_encapsulate'))
print(str(test.get_holder_encapsulate()))

Результат теста:

foo
Destruct: foo
bar
reset
Destruct: bar
foo_ptr
Destruct: foo_ptr
bar_ptr
foo_finalizer
Destruct: foo_finalizer
bar_finalizer
foo_encapsulate
Destruct: foo_encapsulate
bar_encapsulate
PythonModuleFinalizer
Destruct: bar_finalizer

Since Python’s internal finalization will have completed before the
cleanup function, no Python APIs should be called in or after exit.
The boost::python::shared_ptr_deleter will do so, though.

Destruct: bar_ptr
Destruct: bar_encapsulate
Destruct: holder without shared_ptr_deleter