----- Original Message -----

From: Jason Addison <jraddison@gmail.com> To: cplusplus-sig@python.org Cc: Sent: Saturday, May 23, 2015 6:05 PM Subject: [C++-sig] Returning values to Python in C++ reference arguments

How can results be returned in function arguments?

I don't think that you can return arguments by reference/pointers in python. You could theoretically pass a mutable sequence (list) and push the objects there. But the common approach is to return tuple.

Von: Jason Addison

How can results be returned in function arguments?

I've include my example C++ extension and Python code below.

I've tried, what I think, are some obvious approaches (Python objects, ctypes), though none have worked.

It seems like this should be doable.

As already mentioned, you can use helper functions and return tuples. Or you could expose custom "ref-object" classes to Python, s.th. along the lines of: // ref_object.hpp #if !defined REF_OBJECT #define REF_OBJECT #include <boost/python.hpp> #include <algorithm> namespace bp = boost::python; namespace refob { // Basic RefObject template<typename T> struct RefObject { public: T t; RefObject(); // callable operator T operator()(); // conversion functions: implicit castability operator T&() { return t; } }; // RefObject for handling C-style arrays // This provides an operator() that allows access to // a list of values. // NOTE: If numElements > the actual stored number of elements then // THIS WILL CRASH! It is essential to correctly apply set_num() after // this has been used as a function argument, in some thin wrappers // There is only some very rudimentary safety in that _numElements is // initialized to 0 // I really don't see a better way to make this safer template<typename T> struct RefObject<T const *> { T const * t; RefObject(); // callable operator bp::list operator()(unsigned int numElements=0); // conversion functions: implicit castability operator T const *&() { return t; } void set_num(unsigned int const & numElements); private: unsigned int _numElements; }; // RefObject specialization for void* template<> struct RefObject<void *> { void* t; RefObject(); // callable operator void* operator()(); }; // RefObject specialization for void const* (where we cast away const for the // operator() call result to make boost work automagically template<> struct RefObject<void const *> { void const * t; RefObject(); // callable operator void* operator()(); }; // RefObject specialization for char const* which boost.python will automatically // handle as a python string (necessary to distingish from the C-style array // handling RefObject, see above template<> struct RefObject<char const *> { char const * t; RefObject(); // callable operator char const* operator()(); }; // Is inlining the way to go to avoid multiply defined symbols here? // Note: Remember that // * a specialization is not a template but a concrete (member function in // this case) // * as ref_object.hpp are // #included from every module there will be multiple definitions (one // in each compilation unit) // ==> linker chokes // Using inline this can be avoided // See // http://msdn.microsoft.com/en-us/magazine/cc163769.aspx // http://www.parashift.com/c++-faq-lite/inline-functions.html // for background template <typename T> RefObject<T>::RefObject(): t() { //std::cout << "RefObject<" << typeid(T).name() << ">::RefObject()" << std::endl; } template <typename T> RefObject<T const *>::RefObject(): t(), _numElements(0) { //std::cout << "RefObject<" << typeid(T).name() << " const *>::RefObject()" << std::endl; } inline RefObject<void *>::RefObject(): t() { //std::cout << "RefObject<void *>::RefObject()" << std::endl; } inline RefObject<void const *>::RefObject(): t() { //std::cout << "RefObject<void const *>::RefObject()" << std::endl; } inline RefObject<char const *>::RefObject(): t() { //std::cout << "RefObject<char const *>::RefObject()" << std::endl; } template <typename T> T RefObject<T>::operator()() { // Do we need to care about pointer data issues here? return t; } template<typename T> bp::list RefObject<T const *>::operator()(unsigned int numElements) { bp::list list_object; unsigned int maxElements = std::min(numElements, _numElements); for (unsigned int i=0; i < maxElements; i++) { bp::object item(*t); list_object.append(item); } return list_object; } inline void* RefObject<void const *>::operator()() { void* non_const_ptr = const_cast<void*>(t); //std::cout << "returning non-const void* t" << std::endl; return non_const_ptr; } inline void* RefObject<void *>::operator()() { return t; } inline char const* RefObject<char const *>::operator()() { return t; } template<typename T> void RefObject<T const *>::set_num(unsigned int const & numElements) { _numElements = numElements; } } // namespace refob #endif // #if !defined REF_OBJECT And you might expose those to Python: // ref_object.cpp #include <boost/python.hpp> #include "ref_object.hpp" namespace bp = boost::python; namespace refob { // dummy function, expose this to force creation of void* converters in boost registry void* void_ptr_from_void_ptr(void* void_ptr) { return void_ptr; } void export_reference_type_classes() { // // dummy function registration to force creation of void* converters // // (not necessary if there is an exposed function returning void*) // bp::def("void_ptr_from_void_ptr", &void_ptr_from_void_ptr, // bp::return_value_policy<bp::return_opaque_pointer>()); // const-pointer types // 1. char // 1.1: const char* bp::class_<RefObject<const char*>, boost::noncopyable> ("const_char_ptr_ref") .def(bp::init<>()) .def("__call__", &RefObject<const char*>::operator()) ; // 2. numeric types (float/double/int) // Note: signed and unsigned char are *numeric* types usage-wise // const signed char* // bp::class_<RefObject<const signed char*>, boost::noncopyable> ("const_signed_char_ptr_ref") // .def(bp::init<>()) // .def("__call__", &RefObject<const signed char*>::operator()) // ; // // const unsigned char* // bp::class_<RefObject<const unsigned char*>, boost::noncopyable> ("const_unsigned_char_ptr_ref") // .def(bp::init<>()) // .def("__call__", &RefObject<const unsigned char*>::operator()) // ; // const double* bp::class_<RefObject<const double*>, boost::noncopyable> ("const_double_ptr_ref") .def(bp::init<>()) .def("__call__", &RefObject<const double*>::operator()) ; bp::implicitly_convertible< RefObject<const double*>, double const * > (); // // const float* // bp::class_<RefObject<const float*>, boost::noncopyable> ("const_float_ptr_ref") // .def(bp::init<>()) // .def("__call__", &RefObject<const float*>::operator()) // ; // // const short* // bp::class_<RefObject<const short*>, boost::noncopyable> ("const_short_ptr_ref") // .def(bp::init<>()) // .def("__call__", &RefObject<const short*>::operator()) // ; // // const unsigned short* // bp::class_<RefObject<const unsigned short*>, boost::noncopyable> ("const_unsigned_short_ptr_ref") // .def(bp::init<>()) // .def("__call__", &RefObject<const unsigned short*>::operator()) // ; // // const int* // bp::class_<RefObject<const int*>, boost::noncopyable> ("const_int_ptr_ref") // .def(bp::init<>()) // .def("__call__", &RefObject<const int*>::operator()) // ; // // const unsigned int* // bp::class_<RefObject<const unsigned int*>, boost::noncopyable> ("const_unsigned_int_ptr_ref") // .def(bp::init<>()) // .def("__call__", &RefObject<const unsigned int*>::operator()) // ; // // const long long* // bp::class_<RefObject<const long long*>, boost::noncopyable> ("const_long_long_ptr_ref") // .def(bp::init<>()) // .def("__call__", &RefObject<const long long*>::operator()) // ; // // const unsigned long long* // bp::class_<RefObject<const unsigned long long*>, boost::noncopyable> ("const_unsigned_long_long_ptr_ref") // .def(bp::init<>()) // .def("__call__", &RefObject<const unsigned long long*>::operator ()) // ; // 3. void // const void* bp::class_<RefObject<const void*>, boost::noncopyable> ("const_void_ptr_ref") .def(bp::init<>()) .def("__call__", &RefObject<const void*>::operator(), bp::return_value_policy<bp::return_opaque_pointer>()) ; // NON-const-pointer types: // void* bp::class_<RefObject<void*>, boost::noncopyable>("void_ptr_ref") .def(bp::init<>()) .def("__call__", &RefObject<void*>::operator(), bp::return_value_policy<bp::return_opaque_pointer>()) ; // Basic types // 1. char types // char bp::class_<RefObject<char>, boost::noncopyable>("char_ref") .def(bp::init<>()) .def("__call__", &RefObject<char>::operator()) ; // 2. numeric types // Note: signed and unsigned char are *numeric* types usage-wise // const signed char* // signed char bp::class_<RefObject<signed char>, boost::noncopyable> ("signed_char_ref") .def(bp::init<>()) .def("__call__", &RefObject<signed char>::operator()) ; // unsigned char bp::class_<RefObject<unsigned char>, boost::noncopyable> ("unsigned_char_ref") .def(bp::init<>()) .def("__call__", &RefObject<unsigned char>::operator()) ; // double bp::class_<RefObject<double>, boost::noncopyable>("double_ref") .def(bp::init<>()) .def("__call__", &RefObject<double>::operator()) ; // float bp::class_<RefObject<float>, boost::noncopyable>("float_ref") .def(bp::init<>()) .def("__call__", &RefObject<float>::operator()) ; // short bp::class_<RefObject<short>, boost::noncopyable>("short_ref") .def(bp::init<>()) .def("__call__", &RefObject<short>::operator()) ; // unsigned short bp::class_<RefObject<unsigned short>, boost::noncopyable> ("unsigned_short_ref") .def(bp::init<>()) .def("__call__", &RefObject<unsigned short>::operator()) ; // int bp::class_<RefObject<int>, boost::noncopyable>("int_ref") .def(bp::init<>()) .def("__call__", &RefObject<int>::operator()) ; // unsigned int bp::class_<RefObject<unsigned int>, boost::noncopyable> ("unsigned_int_ref") .def(bp::init<>()) .def("__call__", &RefObject<unsigned int>::operator()) ; bp::implicitly_convertible< RefObject<unsigned int>, unsigned int >(); // long long bp::class_<RefObject<long long>, boost::noncopyable>("long_long_ref") .def(bp::init<>()) .def("__call__", &RefObject<long long>::operator()) ; // unsigned long long bp::class_<RefObject<unsigned long long>, boost::noncopyable> ("unsigned_long_long_ref") .def(bp::init<>()) .def("__call__", &RefObject<unsigned long long>::operator()) ; }; } // namespace refob Add to your module (or consider putting into a separate extension module): namespace refob { //forward declaration must be in appropriate namespace void export_reference_type_classes(); // helpers/ref_object.cpp } BOOST_PYTHON_MODULE(my_module) { refob::export_reference_type_classes(); ... You'd then have to use the specialized ref objects as function arguments, much like what you tried with the ctypes stuff: import my_module f = my_module.Foo() a = my_module.int_ref(0) b = my_module.double_ref(0) f.bar(a, b) print "a result:", a() If such effort makes sense depends on how "reference-call-littered" the C++ API you wrap is. Note: I hand-edited the original code a little to remove some irrelevant stuff and didn't try to compile and run it afterwards. But you get the idea. Holger Landesbank Baden-Wuerttemberg Anstalt des oeffentlichen Rechts Hauptsitze: Stuttgart, Karlsruhe, Mannheim, Mainz HRA 12704 Amtsgericht Stuttgart