使用Boost Python导出const wchar_t * c ++函数

Question

I'm trying to expose a c++ function taking a const wchar_t* as a parameter in python. It seems to me that const wchar_t* is not a supported input type that is automatically exposed as a python string and then converted automatically like an ordinary const char*.

Is it possible to add some kind of input type converter that gets this right automatically? I know I can add trampoline functions and do the unicode conversion myself but it would be much more convenient to get this to behave right automatically.

My boost version is 1.52 and I'm working with python 2.7 on 64bit windows.

Here is example code for a trivial c++ sequence showing the issue:

#include <boost/python.hpp>
#include <iostream>
using namespace boost::python;
void testWcharParam(const wchar_t* str) {
    std::wcout << str << std::endl;
}
void testCharParam(const char* str) {
    std::wcout << str << std::endl;
}
BOOST_PYTHON_MODULE(test)
{
    def("testWcharParam", testWcharParam);
    def("testCharParam", testCharParam);
}

When importing and running this in python I get the following result:

>>> import test
>>> test.testCharParam('test')
test
>>> test.testWcharParam('test')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
Boost.Python.ArgumentError: Python argument types in
    test.testWcharParam(str)
did not match C++ signature:
    testWcharParam(wchar_t const * __ptr64)
>>>

For some reason the approach for strings here http://www.boost.org/doc/libs/1_52_0/libs/python/doc/v2/faq.html#custom_string doesn't work for raw wchar_t*.

EDIT: Added missing includes and platform information.

EDIT: Added note on the example in the boost documentation

Answer 1

As far as I know, there is no way to get automatic conversions from Python narrow strings ( str ) to const wchar_t* .

When Boost.Python attempts to convert from Python objects, it allocates memory on the stack to hold the destination type, then attempts to locate converters registered for the destination type. In this case, the destination type would be const wchar_t* . Once a converter has indicated that the PyObject is a valid candidate for conversion, the conversion will occur, initializing the destination type in the stack-allocated memory. With the Python/C API only supporting creating a new PyObject when encoding, memory management becomes an issue, as Boost.Python only allocated memory for wchar_t* .

As Boost.Python does not provide a post-hook to be invoked after the converted value has been used, one simple compromise may be to change the parameter types of const wchar_t* to std::wstring . As std::wstring manages its own memory, Boost.Python can copy the PyObject wide string into it. Additionally, when necessary, Boost.Python will encode narrow strings to wide strings during the conversion to std::wstring .

Example code:

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

void testWcharParam(std::wstring str) { std::wcout << str << std::endl; }
void testCharParam(const char* str)   { std::wcout << str << std::endl; }

BOOST_PYTHON_MODULE(example)
{
  namespace python = boost::python;
  python::def("testWcharParam", testWcharParam);
  python::def("testCharParam", testCharParam);
}

Usage:

>>> import example
>>> example.testCharParam('test 1')
test 1
>>> example.testWcharParam(u'test 2')
test 2
>>> example.testWcharParam('test 3')
test 3

Answer 2

我没有使用Boost Python，但是Python 2中的wchar_t是Unicode字符串，因此请尝试：

>>> test.testWcharParam(u'test')

Answer 3

This is what I ended up using:

void* convert_to_wcstring(PyObject* obj)
{
    if(PyString_Check(obj)) {
        throw_error_already_set();
    } else if(PyUnicode_Check(obj)) {
        return PyUnicode_AsUnicode(obj);
    }
    throw_error_already_set();
    return 0;
}

Then adding it as a converter in:

BOOST_PYTHON_MODULE(test)
{
    converter::registry::insert(convert_to_wcstring, type_id<wchar_t>(),&converter::wrap_pytype<&PyString_Type>::get_pytype);
    ...
}

This works as long as the input parameter is of unicode type rather than an ordinary string type. For my initial example it would give the following result:

# Works
test.testWcharParam(u'test')

# Doesn't work
test.testWcharParam('test')

In my case the C++ API is more rigid than the python one which means I'm in much better position to sanitize input strings there than on the C++ side.

Thanks for all answers, you led me in the right direction but I had to tweak things a bit in order to get something to solve my exact use case.