Предоставление конструктора с массивом другого класса в качестве аргумента

Question

У меня есть два разных класса, которые я хочу показать с использованием boost-python, но конструктор второго принимает в качестве аргумента массив первого, и я не могу понять, как это сделать.

Это определение классов:

class INT96{
public:
    uint64_t value[3];

    INT96(){};
    INT96(uint64_t x0, uint64_t x1, uint64_t x2);
    ...
};

template <unsigned k>
class Xi_CW{
    protected:
        INT96 A[k];

    public:
        Xi_CW(INT96 (&A)[k]);
        ...
};

И моя попытка выставить их используя boost-python:

using namespace boost::python;    
typedef Xi_CW<4> Xi_CW4;

BOOST_PYTHON_MODULE(xis)
{
    class_<INT96>("INT96", init<double,double,double>())
        [...]
    ;
    class_<Xi_CW4>("Xi_CW4", init<INT96[4]>())
        [...]
    ;
}

Что приводит к "неизвестной ошибке преобразования". Я попробовал несколько других возможностей, но пока не повезло...

Есть идеи, как мне это сделать? Спасибо

Answer 1

Одним из решений является подавление инициализатора Boost.Python по умолчанию и регистрация инициализатора custon, который может создать Xi_CW<4> объект из итеративного объекта Python, который содержит INT96 объекты.

• Инициализатор по умолчанию может быть подавлен путем предоставления boost::python::no_init как init_spec выставляя класс через boost::python::class_,
• Вспомогательная функция, обернутая boost::python::make_constructor() может быть выставлен как __init__ метод на занятии.

---

Вот полный пример, основанный на типах, представленных в исходном вопросе:

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

/// @brief Mockup spam class.
struct spam
{
  int value[3];
  spam() {};
  spam(int x, int y, int z)
  {
    value[0] = x;
    value[1] = y;
    value[2] = z;
  }

};

/// @brief Mockup egg class.
template <std::size_t N>
class egg
{
public:

  explicit egg(spam (&spams)[N]) : spams_(spams) {}

  /// @brief Return string reprenstation of the egg class.
  std::string to_string()
  {
    std::stringstream stream;
    stream << "[";
    BOOST_FOREACH(spam& s, spams_)
    {
      stream << "[" << s.value[0] << ", " 
                    << s.value[1] << ", "
                    << s.value[2]
             << "]";
    }
    stream << "]";
    return stream.str();
  }

private:
  spam spams_[N];
};

/// @brief Auxiliary function that will attempt to create an egg<N> type
///        from an iterable Python object that contains spam objects.
template <std::size_t N>
egg<N>* make_egg(boost::python::object object)
{
  spam spams[N];
  // Iterate over the python object, extracting and copying spam objects.
  // Boost.Python will handle throwing exceptions for the appropriate cases:
  // - object does not support indexing (__getitem__)
  // - object[N-1] is out of range
  // - object[i] does not contain or cannot be converted to a spam&
  for (long i = 0; i < N; ++i)
    spams[i] = boost::python::extract<spam&>(object[i]);

  // Construct egg from the local spam array.  Ownership of the object is
  // passed to Boost.Python
  return new egg<N>(spams);
}

/// @brief Expose an egg<N> type to Python.
///
/// @param name The name that will be exposed to Python.
template <std::size_t N>
boost::python::class_<egg<N> > expose_egg(const char* name)
{
  namespace python = boost::python;

  // Explicitly suppress the Boost.Python default constructor.
  typedef egg<N> egg_type;
  python::class_<egg_type> egg_class(name, python::no_init);

  // Register a custom factory function as the constructor method.
  egg_class
    .def("__init__", python::make_constructor(&make_egg<N>))
    .def("__str__", &egg_type::to_string)
    ;

  return egg_class;
}

BOOST_PYTHON_MODULE(example)
{
  namespace python = boost::python;

  // Expose spam.
  python::class_<spam>("Spam", python::init<int, int, int>());

  // Expose different egg types.
  expose_egg<2>("Egg2");
  expose_egg<4>("Egg4");
}

Интерактивное использование:

>>> import example
>>> spams = [
...   example.Spam(0, 1, 2),
...   example.Spam(1, 2, 3),
...   example.Spam(2, 3, 4),
...   example.Spam(3, 4, 5)
... ]
>>> print example.Egg2(spams)
[[0, 1, 2][1, 2, 3]]
>>> print example.Egg4(tuple(spams)) # different type
[[0, 1, 2][1, 2, 3][2, 3, 4][3, 4, 5]]
>>> print example.Egg4(spams[:1]) # expect IndexError
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range
>>> print example.Egg4(42) # expect TypeError (42[0] is invalid)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object has no attribute '__getitem__'
>>> print example.Egg4([42]) # expect TypeError (conversion)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: No registered converter was able to extract a C++ reference to
           type spam from this Python object of type int

Answer 2

Я считаю, что вы могли бы использовать boost:: python:: list для вашего конструктора, чтобы получить массив int96, а затем преобразовать его в обычный массив C++, если хотите.

Вот пример, который я нашел для преобразования итераций Python в вектор C++: /questions/40949506/boostpython-spisok-python-dlya-stdvector/40949519#40949519