{tp_alloc， tp_dealloc} 和 {tp_new， tp_free} 是否应被视为对

tp_alloc中创建的任何内容都应该在tp_dealloc中销毁吗？ 同样，对于{tp_new，tp_free}？

它看起来像一个明显的对称性，但我希望得到澄清。

我的实际用例是这样的：我有：

class OSClass : PyObject {...}
class Final : OSClass {...}

所以相应的PyTypeObject pto有：

pto->tp_basicsize = sizeof(FinalClass)
pto->tp_dealloc = (destructor) 
                  [](PyObject* pyob) { PyMem_Free(pyob); };

但是，新的样式类将 PyObject 及其相应的 C++ 对象彼此分开存储，因此工作方式不同。

它在tp_new中创建 PyObject，在tp_init中创建相应的 C++ 对象。

并在tp_dealloc中摧毁了他们两个

这是正确/最佳的吗？

法典：

// extra void* to point to corresponding C++ object
pto->tp_basicsize = sizeof(PyObject) + sizeof(void*)
pto->tp_new = new_func;
pto->tp_init = init_func;
pto->tp_dealloc = dealloc_func;
static PyObject* new_func( PyTypeObject* subtype, PyObject* args, PyObject* kwds )
{
    // First we create the Python object.
    // The type-object's tp_basicsize is set to sizeof(Bridge)
    // (Note: We could maybe use PyType_GenericNew for this:
    //   http://stackoverflow.com/questions/573275/python-c-api-object-allocation )
    //
    PyObject* pyob = subtype->tp_alloc(subtype,0);
    Bridge* bridge = reinterpret_cast<Bridge*>(pyob);
    // We construct the C++ object later in init_func (below)
    bridge->m_pycxx_object = nullptr;
    return pyob;
}

static int init_func( PyObject* self, PyObject* args, PyObject* kwds )
{
    try
    {
        Object a = to_tuple(args);
        Object k = to_dict(kwds);
        Bridge* bridge{ reinterpret_cast<Bridge*>(self) };
        // NOTE: observe this is where we invoke the 
        //       constructor, but indirectly (i.e. through final)
        bridge->m_pycxx_object = new FinalClass{ bridge, a, k };
    }
    catch( Exception & )
    {
        return -1;
    }
    return 0;
}
static void dealloc_func( PyObject* pyob )
{
    auto final = static_cast<FinalClass*>( cxxbase_for(pyob) );
    delete final;
    PyMem_Free(pyob);
    COUT( "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" );
    //self->ob_type->tp_free(self);
}