Kurz gesagt, unterstützt Boost.Python nicht move-semantics und unterstützt daher std::unique_ptr nicht. Boost.Pythons news/change log hat keinen Hinweis darauf, dass es für C++ 11 move-semantics aktualisiert wurde. Darüber hinaus wurde diese feature request für unique_ptr Unterstützung seit über einem Jahr nicht berührt.
Nichtsdestotrotz unterstützt Boost.Python die Übertragung der exklusiven Eigentümerschaft eines Objekts von und nach Python über std::auto_ptr.Als unique_ptr im Wesentlichen eine sicherere Version von auto_ptr ist, sollte es recht einfach sein, eine API mit unique_ptr an eine API anzupassen, die auto_ptr verwendet:
- Wenn C++ überträgt das Eigentum an Python, die C++ Funktion muss:
- Wenn Eigentum Python Transfers zu C++, die C++ Funktion muss:
- die Instanz über
auto_ptr akzeptieren. Die FAQ erwähnt, dass Zeiger, die von C++ mit einer manage_new_object Richtlinie zurückgegeben werden, über std::auto_ptr verwaltet werden.
- haben
auto_ptr Freigabesteuerung zu einem unique_ptr über release()
eine API/Bibliothek gegeben, die nicht geändert werden können:
/// @brief Mockup Spam class.
struct Spam;
/// @brief Mockup factory for Spam.
struct SpamFactory
{
/// @brief Create Spam instances.
std::unique_ptr<Spam> make(const std::string&);
/// @brief Delete Spam instances.
void consume(std::unique_ptr<Spam>);
};
Die SpamFactory::make() und SpamFactory::consume() gewickelt werden müssen, über Hilfsfunktionen.
Funktionen Eigentum von C++ zu Python übertragen können allgemein durch eine Funktion eingewickelt werden, die Python-Funktion Objekte erstellen wird:
/// @brief Adapter a member function that returns a unique_ptr to
/// a python function object that returns a raw pointer but
/// explicitly passes ownership to Python.
template <typename T,
typename C,
typename ...Args>
boost::python::object adapt_unique(std::unique_ptr<T> (C::*fn)(Args...))
{
return boost::python::make_function(
[fn](C& self, Args... args) { return (self.*fn)(args...).release(); },
boost::python::return_value_policy<boost::python::manage_new_object>(),
boost::mpl::vector<T*, C&, Args...>()
);
}
Die Lambda-Delegierten auf die ursprüngliche Funktion und releases() Besitz der Instanz zu Python, und Die Aufrufrichtlinie zeigt an, dass Python den vom Lambda zurückgegebenen Wert übernehmen wird. Die mpl::vector beschreibt die Anrufsignatur zu Boost.Python, die es ermöglicht, Funktionsverteilung zwischen den Sprachen ordnungsgemäß zu verwalten.
Das Ergebnis adapt_unique als SpamFactory.make() ausgesetzt:
boost::python::class_<SpamFactory>(...)
.def("make", adapt_unique(&SpamFactory::make))
// ...
;
generisch SpamFactory::consume() Anpassung ein schwieriger, aber es ist einfach genug, um eine einfache Hilfsfunktion zu schreiben:
/// @brief Wrapper function for SpamFactory::consume_spam(). This
/// is required because Boost.Python will pass a handle to the
/// Spam instance as an auto_ptr that needs to be converted to
/// convert to a unique_ptr.
void SpamFactory_consume(
SpamFactory& self,
std::auto_ptr<Spam> ptr) // Note auto_ptr provided by Boost.Python.
{
return self.consume(std::unique_ptr<Spam>{ptr.release()});
}
Die Hilfsfunktion delegiert an die ursprüngliche Funktion und konvertiert das von Boost.Python bereitgestellte auto_ptr in das von der API benötigte unique_ptr.Die SpamFactory_consume Hilfsfunktion wird als SpamFactory.consume() ausgesetzt:
boost::python::class_<SpamFactory>(...)
// ...
.def("consume", &SpamFactory_consume)
;
Hier ist ein komplettes Code-Beispiel:
#include <iostream>
#include <memory>
#include <boost/python.hpp>
/// @brief Mockup Spam class.
struct Spam
{
Spam(std::size_t x) : x(x) { std::cout << "Spam()" << std::endl; }
~Spam() { std::cout << "~Spam()" << std::endl; }
Spam(const Spam&) = delete;
Spam& operator=(const Spam&) = delete;
std::size_t x;
};
/// @brief Mockup factor for Spam.
struct SpamFactory
{
/// @brief Create Spam instances.
std::unique_ptr<Spam> make(const std::string& str)
{
return std::unique_ptr<Spam>{new Spam{str.size()}};
}
/// @brief Delete Spam instances.
void consume(std::unique_ptr<Spam>) {}
};
/// @brief Adapter a non-member function that returns a unique_ptr to
/// a python function object that returns a raw pointer but
/// explicitly passes ownership to Python.
template <typename T,
typename ...Args>
boost::python::object adapt_unique(std::unique_ptr<T> (*fn)(Args...))
{
return boost::python::make_function(
[fn](Args... args) { return fn(args...).release(); },
boost::python::return_value_policy<boost::python::manage_new_object>(),
boost::mpl::vector<T*, Args...>()
);
}
/// @brief Adapter a member function that returns a unique_ptr to
/// a python function object that returns a raw pointer but
/// explicitly passes ownership to Python.
template <typename T,
typename C,
typename ...Args>
boost::python::object adapt_unique(std::unique_ptr<T> (C::*fn)(Args...))
{
return boost::python::make_function(
[fn](C& self, Args... args) { return (self.*fn)(args...).release(); },
boost::python::return_value_policy<boost::python::manage_new_object>(),
boost::mpl::vector<T*, C&, Args...>()
);
}
/// @brief Wrapper function for SpamFactory::consume(). This
/// is required because Boost.Python will pass a handle to the
/// Spam instance as an auto_ptr that needs to be converted to
/// convert to a unique_ptr.
void SpamFactory_consume(
SpamFactory& self,
std::auto_ptr<Spam> ptr) // Note auto_ptr provided by Boost.Python.
{
return self.consume(std::unique_ptr<Spam>{ptr.release()});
}
BOOST_PYTHON_MODULE(example)
{
namespace python = boost::python;
python::class_<Spam, boost::noncopyable>(
"Spam", python::init<std::size_t>())
.def_readwrite("x", &Spam::x)
;
python::class_<SpamFactory>("SpamFactory", python::init<>())
.def("make", adapt_unique(&SpamFactory::make))
.def("consume", &SpamFactory_consume)
;
}
Interactive Python:
>>> import example
>>> factory = example.SpamFactory()
>>> spam = factory.make("a" * 21)
Spam()
>>> spam.x
21
>>> spam.x *= 2
>>> spam.x
42
>>> factory.consume(spam)
~Spam()
>>> spam.x = 100
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
Boost.Python.ArgumentError: Python argument types in
None.None(Spam, int)
did not match C++ signature:
None(Spam {lvalue}, unsigned int)
Vielen Dank für die ausführliche Antwort! Ich werde das so schnell wie möglich versuchen, aber der Code sieht gut aus! – schlimpf
Und was ist mit std :: unique_ptr, die als add_property definiert ist. Muss ich es in die Klassendefinition einbinden, wo ich eigentlich eine Eigenschaft hinzufüge oder die Definition von to_python_converter wäre eine bessere Übung? –