Cython 中的继承和 std::shared_ptr

Question

假设我在file.h 中有以下简单的 C++ 继承示例：

class Base {};
class Derived : public Base {};

然后，以下代码编译；也就是说，我可以将std::shared_ptr<Derived>分配给std::shared_ptr<Base>：

Derived* foo = new Derived();
std::shared_ptr<Derived> shared_foo = std::make_shared<Derived>(*foo);
std::shared_ptr<Base> bar = shared_foo;

假设我已将类型添加到 decl.pxd:

cdef extern from "file.h":
    cdef cppclass Base:
        pass
    cdef cppclass Derived(Base):
        pass

然后，我要做的是在 file.pyx 中模仿 Cython 中的上述 C++ 赋值：

cimport decl
from libcpp.memory cimport make_shared, shared_ptr

def do_stuff():
    cdef decl.Derived* foo = new decl.Derived()
    cdef shared_ptr[decl.Derived] shared_foo = make_shared[decl.Derived](foo)
    cdef shared_ptr[decl.Base] bar = shared_foo

与 C++ 案例不同，现在失败并出现以下错误（使用 Cython 3.0a6）：

cdef shared_ptr[decl.Base] bar = shared_foo
                                ^
---------------------------------------------------------------

 Cannot assign type 'shared_ptr[Derived]' to 'shared_ptr[Base]'

我应该期待这种行为吗？有什么方法可以模仿 C++ 示例对 Cython 的作用？

编辑：参见。对于下面接受的答案的 cmets，相关功能已添加到 Cython，并且从 3.0a7 版本开始可用。

Answer 1

它应该适用于 Cython>=3.0，因为 @fuglede 做了这个 PR 解决了下面描述的问题（Cython

---

问题是，std::shared_ptr 的 wrapper 错过了

template <class U> shared_ptr& operator= (const shared_ptr<U>& x) noexcept;

属于std::shared_ptr-class。

如果你像这样修补包装器：

cdef extern from "<memory>" namespace "std" nogil:
cdef cppclass shared_ptr[T]:
    ...
    shared_ptr[T]& operator=[Y](const shared_ptr[Y]& ptr)
    #shared_ptr[Y](shared_ptr[Y]&)  isn't accepted

您的代码将编译。

你可能会问，为什么需要operator= 而不是构造函数shared_ptr[Y]，因为：

...
cdef shared_ptr[decl.Base] bar = shared_foo

看起来构造函数 (template <class U> shared_ptr (const shared_ptr<U>& x) noexcept;) 不明确。但这是 Cython 的 C++ 怪癖之一。上面的代码会被翻译成

std::shared_ptr<Base> __pyx_v_bar;
...
__pyx_v_bar = __pyx_v_shared_foo;

而不是

std::shared_ptr<Base> __pyx_v_bar = __pyx_v_shared_foo;

因此 Cython 将检查 operator= 的存在（对我们来说很幸运，因为 Cython 似乎不支持带模板的构造函数，但对运算符支持）。

---

如果您还想在没有修补 memory.pxd 的系统上分发您的模块，您有两个选择：

1. 自己正确包装std::shared_ptr
2. 写一个小实用函数，例如

%%cython
...
cdef extern from *:
    """
    template<typename T1, typename T2>
    void assign_shared_ptr(std::shared_ptr<T1>& lhs, const std::shared_ptr<T2>& rhs){
         lhs = rhs;
    }
    """
    void assign_shared_ptr[T1, T2](shared_ptr[T1]& lhs, shared_ptr[T2]& rhs)
    
...
cdef shared_ptr[Derived] shared_foo
# cdef shared_ptr[decl.Base] bar = shared_foo
# must be replaced through:
cdef shared_ptr[Base] bar 
assign_shared_ptr(bar, shared_foo)
...

这两种选择都有缺点，因此根据您的情况，您可能更喜欢其中一种。

Answer 2

我没有尝试过 Cyton，但是std::shared_ptr 有一个静态转换函数std::static_pointer_cast。我认为这会奏效

std::shared_ptr<Base> bar = std::static_pointer_cast<Base>(shared_foo);

.

def do_stuff():
    cdef decl.Derived* foo = new decl.Derived()
    cdef shared_ptr[decl.Derived] shared_foo = make_shared[decl.Derived](foo)
    cdef shared_ptr[decl.Base] bar = static_pointer_cast[decl.Base] shared_foo

---

附注

您创建shared_foo 的方式可能不是您想要的。在这里，您首先创建一个动态分配的派生。然后，您将创建一个新的动态分配的共享派生，它是原始副本的副本。

// this allocates one Derived
Derived* foo = new Derived(); 
// This allocates a new copy, it does not take ownership of foo
std::shared_ptr<Derived> shared_foo = std::make_shared<Derived>(*foo); 

你可能想要的是：

Derived* foo = new Derived();
std::shared_ptr<Derived> shared_foo(foo); // This now takes ownership of foo

或者只是：

// This makes a default constructed shared Derived
auto shared_foo = std::make_shared<Derived>();