我遇到一个问题,即使用pybind11从c ++基类派生的python类正在被立即销毁(垃圾收集)。我希望C ++获得动态分配对象的所有权,但我似乎无法实现这一点。我尝试过keep_alive,传递shared_ptr<>作为py :: class_ template参数,和py :: return_value_policy ......没有任何工作。我怀疑这只是用户错误。
这是对我所拥有的实际问题的简化,它具有类似架构的更大代码库。更改架构不是一种选择,因此使这个示例工作对我来说至关重要。
我有两个c ++类,我使用pybind11创建了python接口。 A类和B类都有虚方法,所以它们有相应的trampoline类来支持继承。用户调用B :: Run()函数,该函数导致动态分配(通过新)A对象被创建。当我在python中创建这两个类的特化时,如下所示....分段错误,因为在调用B :: Run后立即销毁B :: aBase。
任何想法如何解决这个问题?提前谢谢!
class A
{
public:
A(){};
virtual ~A()
{
std::cout << "In A::~A()\n";
};
virtual char* SayHello()
{
char* x = "\n\nHello from Class A\n\n";
return x;
}
};
class ATramploline : public A
{
public:
using A::A;
char* SayHello() override
{
PYBIND11_OVERLOAD( char*,A,SayHello,);
}
};
class B
{
public:
B()
{
std::cout << "In Class B Constructor\n";
}
void Run()
{
aBase = AllocateAnAClass();
std::cout << aBase->SayHello();
}
virtual ~B()
{
fprintf(stderr,"About to delete aBase");
delete aBase;
}
A* aBase;
virtual A* AllocateAnAClass()
{
return new A;
}
};
class BTramploline : public B
{
public:
using B::B;
A* AllocateAnAClass() override
{
PYBIND11_OVERLOAD( A*,B,AllocateAnAClass,);
}
};
PYBIND11_MODULE(TestModule,m)
{
py::class_<A,ATramploline>(m,"A")
.def(py::init<>(),py::return_value_policy::reference_internal)
.def("SayHello",&A::SayHello);
py::class_<B,BTramploline>(m,"B")
.def(py::init<>())
.def("Run",&B::Run)
.def("AllocateAnAClass",&B::AllocateAnAClass,py::return_value_policy::reference_internal);
}
#!/usr/bin/python3
from TestModule import A,B
class MyA(A):
def __init__(self):
super().__init__()
print("Done with MyA Constructor")
def SayHello(self):
return '\n\nHello from Class MyA\n\n'
class MyB(B):
def __init__(self):
super().__init__()
print("Done With MyB Constructor")
def AllocateAnAClass(self):
print("In MyB::AllocateAnAClass!!!")
return MyA()
#x = B()
#x.Run()
y = MyB()
y.Run()
print("done with test script\n")
答案 0 :(得分:1)
使用std::shared_ptr<A>
作为A
持有者的正确(我认为)方法是将其添加到class_<A...>
个参数中。
您还希望将A*
的每个实例替换为std::shared_ptr<A>
,将new
替换为std::make_shared
。我认为在这种情况下不需要非默认的退货政策,所以我删除了它们;因人而异。
下面的工作模块(纠正了小错误)。
#include <pybind11/pybind11.h>
#include <memory>
#include <iostream>
namespace py = pybind11;
class A
{
public:
A(){};
A(const A&) { std::cout << "Copying A\n"; }
virtual ~A()
{
std::cout << "In A::~A()\n";
};
virtual const char* SayHello()
{
const char* x = "\n\nHello from Class A\n\n";
return x;
}
};
class ATrampoline : public A
{
public:
using A::A;
const char* SayHello() override
{
PYBIND11_OVERLOAD( const char*,A,SayHello,);
}
};
class B
{
public:
B()
{
std::cout << "In Class B Constructor\n";
}
B(const B&) { std::cout << "Copying B\n"; }
void Run()
{
aBase = AllocateAnAClass();
std::cout << aBase->SayHello();
}
virtual ~B()
{
}
std::shared_ptr<A> aBase;
virtual std::shared_ptr<A> AllocateAnAClass()
{
return std::make_shared<A>();
}
};
class BTrampoline : public B
{
public:
using B::B;
std::shared_ptr<A> AllocateAnAClass() override
{
PYBIND11_OVERLOAD(std::shared_ptr<A>,B,AllocateAnAClass,);
}
};
PYBIND11_MODULE(TestModule,m)
{
py::class_<A,std::shared_ptr<A>, ATrampoline>(m,"A")
.def(py::init<>())
.def("SayHello",&A::SayHello);
py::class_<B, BTrampoline>(m,"B")
.def(py::init<>())
.def("Run",&B::Run)
.def("AllocateAnAClass",&B::AllocateAnAClass);
}
答案 1 :(得分:1)
py :: nodelete是解决方案。虽然n.m的答案可行,但它需要返回并将现有库中的所有指针转换为智能指针,这对我来说不是一个可行的选择。使用py :: nodelete允许我在pybind11端执行所有操作。
py::class_<A,ATramploline,std::unique_ptr<A,py::nodelete> >(m,"A")
.def(py::init<>())
.def("SayHello",&A::SayHello);