Boost python не будет автоматически преобразовывать элементы данных char *

Давайте предположим, что мы обертываем какой-то сторонний API, и отбросим в сторону ужас, связанный с тем, что эти указатели выставлены напоказ и возятся с ними извне.

Вот краткое доказательство концепции:

#include <boost/python.hpp>
namespace bp = boost::python;

class example
{
public:
    example()
    {
        text = new char[1];
        text[0] = '\0';
    }

    ~example()
    {
        delete[] text;
    }

public:
    char* text;

};

char const* get_example_text(example* e)
{
    return e->text;
}

void set_example_text(example* e, char const* new_text)
{
    delete[] e->text;

    size_t n(strlen(new_text));
    e->text = new char[n+1];
    strncpy(e->text, new_text, n);
    e->text[n] = '\0';
}

BOOST_PYTHON_MODULE(so02)
{
    bp::class_<example>("example")
        .add_property("text", &get_example_text, &set_example_text)
        ;
}

Класс example владеет text и отвечает за управление памятью.

Мы предоставляем внешнюю функцию получения и установки. Геттер прост, он просто предоставляет доступ для чтения к строке. Сеттер освобождает старую строку, выделяет новую память соответствующего размера и копирует данные.

Вот простой тест в интерпретаторе Python:

>>> import so02
>>> e = so02.example()
>>> e.text
''
>>> e.text = "foobar"
>>> e.text
'foobar'

Примечания:

• set_example_text() может, возможно, взять std::string или bp::object, чтобы у нас была легко доступная длина, и потенциально можно было бы присваивать больше, чем просто строки.
• Если есть много переменных-членов для переноса и шаблон получения/установки аналогичен, сгенерируйте код с использованием шаблонов или даже нескольких макросов.
• Возможно, есть способ сделать это с помощью преобразователей, я посмотрю на это завтра. Однако, поскольку здесь мы имеем дело с управлением памятью, лично я бы предпочел сделать это таким образом, так как гораздо более очевидно, что происходит.

Это расширяет ответ Дэна. Я написал несколько определений макросов, которые генерируют лямбда-выражения. Преимущества этого подхода заключаются в том, что он не привязан к конкретному типу или имени члена.

В API, который я оборачиваю, мне нужно обернуть несколько сотен классов. Это позволяет мне сделать один вызов макроса для каждого члена класса char*.

Вот модифицированная версия примера кода Дэна:

#include <boost/python.hpp>
namespace bp = boost::python;

#define ADD_PROPERTY(TYPE, ATTR) add_property(#ATTR, SET_CHAR_P(TYPE, ATTR), \
                                              GET_CHAR_P(TYPE, ATTR))

#define SET_CHAR_P(TYPE, ATTR) +[](const TYPE& e){                  \
                                   if (!e.ATTR) return "";          \
                                   return (const char*)e.ATTR;      \
                               }
#define GET_CHAR_P(TYPE, ATTR) +[](TYPE& e, char const* new_text){  \
                                   delete[] e.ATTR;                 \
                                   size_t n(strlen(new_text));      \
                                   e.ATTR = new char[n+1];          \
                                   strncpy(e.ATTR, new_text, n);    \
                                   e.ATTR[n] = '\0';                \
                               }

class example
{
public:
    example()
    {
        text = new char[1];
        text[0] = '\0';
    }

    ~example()
    {
        delete[] text;
    }

public:
    char* text;

};


BOOST_PYTHON_MODULE(topics)
{
    bp::class_<example>("example")
        .ADD_PROPERTY(example, text);
}