虚拟继承C++；和增强python 在我正在玩的游戏中，我有两个C++类（可ICLE和SpRITE），它实际上继承了另一个称为对象的C++类，因为它的属性位置和大小。我使用boostpython将这三个类公开给python。python中的播放器类构造函数如下所示，例如： class Player(Game.ICollidable, Game.Sprite, Game.IKeyboardListener, Game.IEntity): def __init__(self): Game.IKeyboardListener.__init__(self) Game.IEntity.__init__(self) Game.ICollidable.__init__(self) Game.Sprite.__init__(self)

问题是，当精灵init位于IColliable的init之前时，精灵位置无法正常工作，我无法在屏幕上重新定位精灵。我想现在发生的是，在我创建IColliable类之前，我认为会发生的是，Sprite和IColliable中的位置是不同的

我尝试了各种各样的方法来解决这个问题，在互联网上寻找解决这个问题的方法，但是我空手而归。如有任何建议、解决方案或提示，将不胜感激

编辑：

这是我的C++类的python绑定：

class_<Object>("GameObject")
    .def_readwrite("Pos", &Object::pos)
    .def_readwrite("Size",&Object::size)
;
class_<Sprite, bases<Object>>("Sprite", init<>())
    // Sprite(TexID, Pos)
    .def(init<GLuint, glm::vec2>())
    // ----------------------------
    .def_readwrite("TexId", &Sprite::texid)
;
class_<ICollidableWrap, bases<Object>,boost::noncopyable>("ICollidable", init<>())
    //.def("Pos", &ICollidable::Object::pos)
    .def("Test", pure_virtual(&ICollidable::Test))
    .def("OnCollision",pure_virtual(&ICollidable::OnCollision))
;

类（“游戏对象”）
.def_readwrite（“Pos”和对象：：Pos）
.def_readwrite（“大小”和对象：：大小）
;
类（“精灵”，init（））
//雪碧（TexID，Pos）
.def（init（））
// ----------------------------
.def_readwrite（“TexId”和Sprite:：TexId）
;
类（“IColliable”，init（））
//.def（“Pos”，&icolliable:：Object:：Pos）
.def（“测试”，纯虚拟（&IColliable:：测试））
.def（“OnCollision”，纯虚拟（&IColliable:：OnCollision））
;

虽然两种语言都提供了解决方案，但它们使用不同的方法。C++移除了虚拟继承的模糊性，导致单个子对象被共享。另一方面，Python通过单调的超类线性化查找来消除歧义。由于Python继承不会导致C++类型共享单个子对象，所以Python类需要在Python类继承两个共享共同虚拟基的暴露C++类时，模拟C++虚拟继承。不幸的是，正如我所知，Boost.Python不支持这种情况，因为提供给的类型没有检查虚拟继承

虽然不是可伸缩的，可能是一个值得研究的基于组合的解决方案，但是一个简单的继承解决方案是从 ICOLIDABLeReX和 SpRITE < /C> >中继承一个<代码> CuldDabLePrime< /Cult> C++类，然后让Python类继承<代码> CurrdabLePrime< /C> >

---

下面是一个基本示例，其中类

C

从

B

继承，而

a

从

V

虚拟继承：

#include <boost/python.hpp>

/// @brief Mock up forming the following multiple inheritance
///        structure:
///
///            .-->[ V ]<--.
///            |           |
///          [ A ]       [ B ]
///            |           |
///            '---[ C ] --'
struct V
{
  V() : x(0) {}
  virtual ~V() {}
  unsigned int x;
};

struct A : virtual public V {};
struct B : virtual public V {};
struct C : public A, public B {};

/// @brief Functions that force an object's hierarchy chain to be
///        split, disambiguating access to V.x.
void print_a(A& a) { std::cout << a.x << std::endl; }
void print_b(B& b) { std::cout << b.x << std::endl; }

BOOST_PYTHON_MODULE(example)
{
  namespace python = boost::python;
  // Expose hierarchy.
  python::class_<V>("V", python::no_init)
    .def_readwrite("x", &V::x)
    ;
  python::class_<A, python::bases<V> >("A");
  python::class_<B, python::bases<V> >("B");
  python::class_<C, python::bases<A, B> >("C");

  // Expose helper functions.
  python::def("print_a", &print_a);
  python::def("print_b", &print_b);
}

---

如果有用的话，我将包含向python公开类的包装器代码。我的第一个猜测是，您是通过值而不是引用传递参数，但这只是一个猜测，您应该提供更多信息……我在boost python绑定中添加了这些信息，希望它能够提供解决此问题所需的有用信息。谢谢您的回答，这就是我将采用的解决方案。