如何用Cython扩展类型替代C结构体？性能与继承方案解析

我需要创建能在不同函数间传递的数据结构，目前用C风格结构体存储数据并在类A中传递，但C结构体不支持继承，没法在子类B里用结构体的子类。我尝试用纯Cython扩展类型替代结构体来支持继承，同时想保留nogil操作的性能，但试写的代码跑不起来。具体问题如下：

1. 怎么正确用无Python对象的纯Cython类替代结构体，同时支持nogil操作？
2. 两者性能有差异吗？
3. 如果没法替代，原因是什么？有哪些类结构体数据传递的替代方案？

当前使用C结构体的代码 #

# right now we use a C-struct to hold data that is passed
# around in a separate class 'A'
cdef struct Record:
    double threshold       
    double improvement     

cdef class A:

   cpdef py_dostuff(self):
         cdef Record record
         
         record.threshold = new_threshold
         record.improvement = new_improvement
         
         cy_dostuff(&record)
   cdef void cy_dostuff(self, Record record) nogil:
         do_some_computation(record.threshold, record.improvement)

尝试使用Cython扩展类型的代码 #

# now, I would like to use a Cython extension type to hold data that is passed
# around in a separate class 'A'
cdef class Record:
    cdef double threshold       
    cdef double improvement     

cdef class A:

   cpdef py_dostuff(self):
         cdef Record record
         
         record.threshold = new_threshold
         record.improvement = new_improvement
         
         cy_dostuff(&record)

   cdef void cy_dostuff(self, Record record) nogil:
         do_some_computation(record.threshold, record.improvement)

# The reason I would like to use a Cython extension type is that it can then support clean inheritance of the data structure
cdef class NewRecord(Record):
    cdef double threshold       
    cdef double improvement     
    cdef int new_attribute

# E.g. a new subclass of 'A' would still work even if all we did was extend the logic to a "NewRecord"
cdef class B(A):
    cpdef py_dostuff(self):
         cdef NewRecord record
         
         record.threshold = new_threshold
         record.improvement = new_improvement
         record.new_attribute = new_attribute

         cy_dostuff(&record)

     cdef void cy_dostuff(self, Record record) nogil:
         do_some_computation(record.threshold, record.improvement, record.new_attribute)

1. 正确使用纯Cython类替代结构体并支持nogil的方法 #

你当前的代码核心问题是：Cython扩展类型本质是Python对象，哪怕只包含cdef字段，创建和访问时仍会涉及Python对象的引用计数操作，默认不能在nogil块里直接使用。要实现类似结构体的无Python对象可继承类型，得用Cython类封装底层C结构体的方式，具体修改如下：

# 定义底层C结构体，用于模拟继承
cdef struct BaseRecord:
    double threshold       
    double improvement     

cdef struct DerivedRecord:
    BaseRecord base
    int new_attribute

# 用Cython类封装基类结构体，手动管理内存
cdef class Record:
    cdef BaseRecord* ptr
    def __cinit__(self):
        self.ptr = <BaseRecord*>malloc(sizeof(BaseRecord))
    def __dealloc__(self):
        free(self.ptr)
    # 用cdef方法封装字段访问，支持nogil
    cdef double get_threshold(self) nogil:
        return self.ptr.threshold
    cdef void set_threshold(self, double val) nogil:
        self.ptr.threshold = val
    cdef double get_improvement(self) nogil:
        return self.ptr.improvement
    cdef void set_improvement(self, double val) nogil:
        self.ptr.improvement = val

# 子类封装派生结构体，复用基类内存管理逻辑
cdef class NewRecord(Record):
    cdef DerivedRecord* d_ptr
    def __cinit__(self):
        self.d_ptr = <DerivedRecord*>malloc(sizeof(DerivedRecord))
        self.ptr = &self.d_ptr.base  # 指向基类部分，实现继承
    def __dealloc__(self):
        free(self.d_ptr)
    cdef int get_new_attribute(self) nogil:
        return self.d_ptr.new_attribute
    cdef void set_new_attribute(self, int val) nogil:
        self.d_ptr.new_attribute = val

# 修改类A和B的逻辑，使用封装后的方法
cdef class A:
    cpdef py_dostuff(self, double new_threshold, double new_improvement):
        cdef Record record = Record()
        record.set_threshold(new_threshold)
        record.set_improvement(new_improvement)
        self.cy_dostuff(record)
    cdef void cy_dostuff(self, Record record) nogil:
        do_some_computation(record.get_threshold(), record.get_improvement())

cdef class B(A):
    cpdef py_dostuff(self, double new_threshold, double new_improvement, int new_attribute):
        cdef NewRecord record = NewRecord()
        record.set_threshold(new_threshold)
        record.set_improvement(new_improvement)
        record.set_new_attribute(new_attribute)
        self.cy_dostuff(record)
    cdef void cy_dostuff(self, Record record) nogil:
        # 向下转型并访问子类字段，注意类型安全
        cdef NewRecord n_record = <NewRecord>record
        do_some_computation(n_record.get_threshold(), n_record.get_improvement(), n_record.get_new_attribute())

这种方式通过底层C结构体实现继承逻辑，上层用Cython类封装，既保留了nogil操作的能力，又实现了数据结构的继承扩展。

2. 性能差异 #

• C结构体：性能最优，直接在栈/堆分配内存，字段访问是纯内存寻址，完全无Python overhead，nogil块里操作毫无压力。
• 封装C结构体的Cython扩展类型：性能接近C结构体，仅多了一层指针封装和cdef方法调用的极轻微开销，绝大多数场景下可以忽略不计。如果直接用纯Cython扩展类型（不封装底层C结构体），因为涉及Python对象的引用计数和类型检查，无法在nogil块里安全操作，且会有明显的性能损耗。

3. 无法直接替代的原因及替代方案 #

无法直接替代的原因 #

Cython扩展类型本质是Python对象，必须遵守Python对象模型：

• 必须在GIL下创建和销毁（除非手动管理内存）
• 字段访问默认会触发Python层面的类型检查和引用计数操作，不能直接在nogil块里操作
• 扩展类型的指针本质是PyObject*，无法像C结构体指针那样直接访问字段，必须额外封装

替代方案 #

1. C结构体模拟继承：用嵌套结构体实现类似继承的效果，完全保留C结构体的性能，缺点是无多态支持，需要手动处理类型转换：

cdef struct Record:
    double threshold       
    double improvement     

cdef struct NewRecord:
    Record base
    int new_attribute

# 使用时直接访问嵌套字段
cdef void cy_dostuff(NewRecord record) nogil:
    do_some_computation(record.base.threshold, record.base.improvement, record.new_attribute)

2. C++类+Cython封装：如果项目允许依赖C++，可以用C的类和继承机制，再用Cython封装成扩展类型，既能享受C的多态特性，又能在nogil块里操作纯C++对象。

3. Cython融合类型（Fused Types）：如果不需要真正的继承，只是需要处理多种结构体类型，可以用融合类型实现泛型逻辑，性能和C结构体一致：

cdef fused RecordType:
    Record
    NewRecord

cdef void cy_dostuff(RecordType record) nogil:
    if RecordType is Record:
        do_some_computation(record.threshold, record.improvement)
    elif RecordType is NewRecord:
        do_some_computation(record.base.threshold, record.base.improvement, record.new_attribute)

内容的提问来源于stack exchange，提问作者ajl123