<copy_const_reference>является модельюResultConverterGenerator, которые могут быть использованы для обертывания функций C++, возвращающих тип отсылки к содержимому таким образом, что указанное значение копируется в новый объект Python.

namespace boost { namespace python
{
    struct copy_const_reference
    {
        template <class T> struct apply;
    };
}}

template <class T> struct apply

Определение модуля C++:

#include <boost/python/module.hpp>
#include <boost/python/class.hpp>
#include <boost/python/copy_const_reference.hpp>
#include <boost/python/return_value_policy.hpp>
// classes to wrap
struct Bar { int x; }
struct Foo {
   Foo(int x) : { b.x = x; }
   Bar const& get_bar() const { return b; }
 private:
   Bar b;
};
// Wrapper code
using namespace boost::python;
BOOST_PYTHON_MODULE(my_module)
{
    class_<Bar>("Bar");
     class_<Foo>("Foo", init<int>())
        .def("get_bar", &Foo::get_bar
            , return_value_policy<copy_const_reference>())
       ;
}

Код Python:

>>> from my_module import *
>>> f = Foo(3)         # create a Foo object
>>> b = f.get_bar()    # make a copy of the internal Bar object

<copy_non_const_reference>является модельюResultConverterGenerator, которая может быть использована для обертывания функций C++, возвращающих тип «ссылка-не-конст», так что указанное значение копируется в новый объект Python.

namespace boost { namespace python
{
    struct copy_non_const_reference
    {
        template <class T> struct apply;
    };
}}

template <class T> struct apply

Определение модуля C++:

#include <boost/python/module.hpp>
#include <boost/python/class.hpp>
#include <boost/python/copy_non_const_reference.hpp>
#include <boost/python/return_value_policy.hpp>
// classes to wrap
struct Bar { int x; }
struct Foo {
   Foo(int x) : { b.x = x; }
   Bar& get_bar() { return b; }
 private:
   Bar b;
};
// Wrapper code
using namespace boost::python;
BOOST_PYTHON_MODULE(my_module)
{
    class_<Bar>("Bar");
     class_<Foo>("Foo", init<int>())
        .def("get_bar", &Foo::get_bar
            , return_value_policy<copy_non_const_reference>())
       ;
}

Код Python:

>>> from my_module import *
>>> f = Foo(3)         # create a Foo object
>>> b = f.get_bar()    # make a copy of the internal Bar object

<manage_new_object>является модельюResultConverterGenerator, которая может быть использована для обертывания функций C++, которые возвращают указатель на объект, выделенный с новым выражением, и ожидают, что абонент возьмет на себя ответственность за удаление этого объекта.

namespace boost { namespace python
{
    struct manage_new_object
    {
        template <class T> struct apply;
    };
}}

template <class T> struct apply

В C++:

#include <boost/python/module.hpp>
#include <boost/python/class.hpp>
#include <boost/python/manage_new_object.hpp>
#include <boost/python/return_value_policy.hpp>
struct Foo {
   Foo(int x) : x(x){}
   int get_x() { return x; }
   int x;
};
Foo* make_foo(int x) { return new Foo(x); }
// Wrapper code
using namespace boost::python;
BOOST_PYTHON_MODULE(my_module)
{
    def("make_foo", make_foo, return_value_policy<manage_new_object>())
    class_<Foo>("Foo")
        .def("get_x", &Foo::get_x)
        ;
}

Код Python:

>>> from my_module import *
>>> f = make_foo(3)     # create a Foo object
>>> f.get_x()
3

<reference_existing_object>является модельюResultConverterGenerator, которая может использоваться для обертывания функций C++, которые возвращают ссылку или указатель на объект C++. Когда функция обертывания называется, значение, на которое ссылается его обратное значение, не копируется. Создается новый объект Python, который содержит указатель на референт, и не предпринимается никаких попыток гарантировать, что срок службы референта по крайней мере такой же, как у соответствующего объекта Python. Таким образом, может бытьочень опасноиспользовать<reference_existing_object>без дополнительного пожизненного управления от таких моделейCallPolicies, как<with_custodian_and_ward>. Этот класс используется в реализации<return_internal_reference>.

namespace boost { namespace python
{
    struct reference_existing_object
    {
        template <class T> struct apply;
    };
}}

template <class T> struct apply

В C++:

#include <boost/python/module.hpp>
#include <boost/python/class.hpp>
#include <boost/python/reference_existing_object.hpp>
#include <boost/python/return_value_policy.hpp>
#include <utility>
// classes to wrap
struct Singleton
{
   Singleton() : x(0) {}
   int exchange(int n)  // set x and return the old value
   {
        std::swap(n, x);
        return n;
   }
   int x;
};
Singleton& get_it()
{
   static Singleton just_one;
   return just_one;
}
// Wrapper code
using namespace boost::python;
BOOST_PYTHON_MODULE(singleton)
{
    def("get_it", get_it,
        return_value_policy<reference_existing_object>());
    class_<Singleton>("Singleton")
       .def("exchange", &Singleton::exchange)
       ;
}

Код Python:

>>> import singleton
>>> s1 = singleton.get_it()
>>> s2 = singleton.get_it()
>>> id(s1) == id(s2)  # s1 and s2 are not the same object
0
>>> s1.exchange(42)   # but they reference the same C++ Singleton
0
>>> s2.exchange(99)
42

<return_by_value>является модельюResultConverterGenerator, которая может быть использована для обертывания функций C++, возвращающих любой тип ссылки или значения, так что возвращаемое значение копируется в новый объект Python.

namespace boost { namespace python
{
    struct return_by_value
    {
        template <class T> struct apply;
    };
}}

template <class T> struct apply

В C++:

#include <boost/python/module.hpp>
#include <boost/python/class.hpp>
#include <boost/python/return_by_value.hpp>
#include <boost/python/return_value_policy.hpp>
// classes to wrap
struct Bar { };
Bar global_bar;
// functions to wrap:
Bar b1();
Bar& b2();
Bar const& b3();
// Wrapper code
using namespace boost::python;
template <class R>
void def_void_function(char const* name, R (*f)())
{
   def(name, f, return_value_policy<return_by_value>());
}
BOOST_PYTHON_MODULE(my_module)
{
    class_<Bar>("Bar");
    def_void_function("b1", b1);
    def_void_function("b2", b2);
    def_void_function("b3", b3);
}

Код Python:

>>> from my_module import *
>>> b = b1() # each of these calls
>>> b = b2() # creates a brand
>>> b = b3() # new Bar object

Return_opaque_pointer - это модельResultConverterGenerator, которая может использоваться для обертывания функций C++, возвращающих указатели к неопределенным типам, таким образом, что возвращаемое значение копируется в новый объект Python.

В дополнение к определению политики<return_opaque_pointer>макрос<BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID>должен использоваться для определения специализации.<type_id>функция по типу, указанному обратным указателем.

namespace boost { namespace python
{
    struct return_opaque_pointer
    {
        template <class R> struct apply;
    };
}}

template <class T> struct apply

В C++:

# include <boost/python/return_opaque_pointer.hpp>
# include <boost/python/def.hpp>
# include <boost/python/module.hpp>
# include <boost/python/return_value_policy.hpp>
typedef struct opaque_ *opaque;
opaque the_op   = ((opaque) 0x47110815);
opaque get () { return the_op; }
void use (opaque op) {
    if (op != the_op)
	throw std::runtime_error (std::string ("failed"));
}
void failuse (opaque op) {
    if (op == the_op)
	throw std::runtime_error (std::string ("success"));
}
BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID(opaque_)
namespace bpl = boost::python;
BOOST_PYTHON_MODULE(opaque_ext)
{
    bpl::def (
        "get", &::get, bpl::return_value_policy<bpl::return_opaque_pointer>());
    bpl::def ("use", &::use);
    bpl::def ("failuse", &::failuse);
}

Код Python:

"""
>>> from opaque_ext import *
>>> #
>>> # Check for correct conversion
>>> use(get())
>>> failuse(get())
Traceback (most recent call last):
        ...
RuntimeError: success
>>> #
>>> # Check that there is no conversion from integers ...
>>> use(0)
Traceback (most recent call last):
        ...
TypeError: bad argument type for built-in operation
>>> #
>>> # ... and from strings to opaque objects
>>> use("")
Traceback (most recent call last):
        ...
TypeError: bad argument type for built-in operation
"""
def run(args = None):
    import sys
    import doctest
    if args is not None:
        sys.argv = args
    return doctest.testmod(sys.modules.get(__name__))
if __name__ == '__main__':
    print "running..."
    import sys
    sys.exit(run()[0])