Блог

У меня есть один чисто абстрактный класс и 2 унаследованных класса, каждый из которых содержит метод, вызываемый go следующим образом:

 // Pure abstract class
class Animal {
public:
    virtual std::string go() = 0;
};

// First inherited class
class Dog : public Animal {
public:
    std::string go() override { return "woof! "; }
};

// Second inherited class
class Cat : public Animal {
public:
    std::string go() override { return "meow! "; }
};
  

На стороне Python определен список созданных объектов (Dog или Cat). На стороне C я пытаюсь написать функцию call_go , которая принимает этот список Python в качестве входных данных и вызывает метод go каждого объекта списка.

 import test

# defining a list of objects Cat or Dog
animals = []
animals.append(test.Cat())
animals.append(test.Dog())
animals.append(test.Cat())

# trying to call for each object of the given list the method "go"
test.call_go(animals)
  

Поскольку я заранее не знаю тип каждого элемента данного списка, я попытался написать функцию call_go , в которой я привел элемент как Animal :

 void call_go(py::list animals) {
  for (py::handle animal : animals) {
    std::cout << py::cast<Animal>(animal).go() << " ";
  }
}
  

Но, как Animal и абстрактный класс, компилятор возвращает:

ошибка: недопустимый абстрактный возвращаемый тип ‘Animal’

Однако, если список полностью определен в коде c , он компилируется и работает отлично:

 void call_go_cpp() {
  std::list<Animal*> animals;

  animals.push_back(new Cat());
  animals.push_back(new Dog());
  animals.push_back(new Cat());

  for(Animal* animal: animals)
    std::cout << animal->go() << std::endl;
}
  

Вы знаете, как решить эту проблему? Я полагаю, это связано с написанием пользовательского приведения.

Полный код C находится здесь:

 #include <iostream>
#include <string>
#include <pybind11/pybind11.h>
#include <pybind11/stl.h>
#include <pybind11/functional.h>

namespace py = pybind11;

// Pure abstract class
class Animal {
public:
    virtual std::string go() = 0;
};

class PyAnimal : public Animal {
public:
    using Animal::Animal;
    std::string go() override { PYBIND11_OVERRIDE_PURE( std::string, Animal, go, ); }
};

// First inherited class
class Dog : public Animal {
public:
    std::string go() override { return "woof! "; }
};

class PyDog : public Dog {
public:
    using Dog::Dog;
    std::string go() override { PYBIND11_OVERRIDE(std::string, Dog, go, ); }
};

// Second inherited class
class Cat : public Animal {
public:
    std::string go() override { return "meow! "; }
};

class PyCat : public Cat {
public:
    using Cat::Cat;
    std::string go() override { PYBIND11_OVERRIDE(std::string, Cat, go, ); }
};

// calling the method "go" for each element of a list (instance of class Dog or Cat) created within the c   code 
void call_go_cpp() {
  std::list<Animal*> animals;

  animals.push_back(new Cat());
  animals.push_back(new Dog());
  animals.push_back(new Cat());

  for(Animal* animal: animals)
    std::cout << animal->go() << std::endl;
}

// trying to call the method "go" for each element of a list (instance of class Dog or Cat) defined on the Python side
void call_go(py::list animals) {
  for (py::handle animal : animals) {
    std::cout << py::cast<Animal>(animal).go() << " ";
  }
}

// Pybind11 bindings
PYBIND11_MODULE(test, m) {
    py::class_<Animal, PyAnimal>(m, "Animal")
        .def(py::init<>())
        .def("go", amp;Animal::go);

    py::class_<Dog, Animal, PyDog>(m, "Dog")
        .def(py::init<>());

    py::class_<Cat, Animal, PyCat>(m, "Cat")
        .def(py::init<>());

    m.def("call_go_cpp", amp;call_go_cpp);
    m.def("call_go", amp;call_go);
}
  

Правильный способ записи call_go

 void call_go(py::list animals) {
  for (py::handle animal : animals) {
    // wrong 
    //std::cout << py::cast<Animal>(animal).go() << " ";
    // correct way
    std::cout << py::cast<Animal *>(animal)->go() << " ";
  }
}
  

Спасибо сообществу pybind11 на https://gitter.im/pybind/Lobby для решения