Question

我一直在尝试将这段代码移植到python中，但是在C ++中有一些我不太懂的东西（我确实知道一些C ++，但这超出了我的范围）：

typedef struct huffnode_s
{
    struct huffnode_s *zero;
    struct huffnode_s *one;
    unsigned char val;
    float freq;
} huffnode_t;

我没有得到的是huffnode_s本身是如何形成的，我以前从未见过它并且不太了解它。这是什么意思，如果有人可以，那将是什么蟒蛇等同？

Answer 1

huffnode_s不在其中，只有指针到huffnode_s。由于指针的大小已知，所以没问题。

Answer 2

此。

class Huffnode(object):
    def __init__(self, zero, one, val, freq):
        """zero and one are Huffnode's, val is a 'char' and freq is a float."""
        self.zero = zero
        self.one = one
        self.val = val
        self.freq = freq

然后，您可以将各种C函数重构为此类的方法。

或许这个。

from collections import namedtuple
Huffnode = namedtuple( 'Huffnode', [ 'zero', 'one', 'val', 'freq' ] )

如果您希望C函数保持功能。

就是这样。

h0 = Huffnode(None, None, 'x', 0.0)
h1 = Huffnode(None, None, 'y', 1.0)
h2 = Huffnode(h0, h1, 'z', 2.0)

这就是所需要的。

Answer 3

它本身没有结构。它有一个指向该结构的指针。

内存中的

struct huffnode_s 看起来像（32位机器）：

| ------------------ huffnode_s * zero - 4个字节-------------- |

| ------------------ huffnode_s * one - 4 bytes ---------------- |

| unsigned char val - 1字节+ 3字节填充======= |

| ------------------- float freq - 4个字节---------------------- --- |

这些尺寸会因机器而异，它在内存中的外观由编译器决定。

Answer 4

为了补充Carl的答案，C ++中也可以这样做：

class Foo {
public:
    Foo() {}

    Foo *anotherFoo;
};

（注意上面的类是愚蠢的，但重点是你可以在一个类类型的类中有一个指针）

Answer 5

正如其他人所指出的那样，对自身的引用只是指向该结构的其他实例的指针。

结构中的指针允许用户将实例连接在一起作为链表。

Answer 6

（struct huffnode_s *）声明指向另一个结构的指针，该结构包含与其声明的结构相同的变量。请参阅this question。

Answer 7

这是一个指向huffnode内部的huffnode的指针。这意味着您可以说：

huffnode_t *node = ...;
huffnode_t *greatgreatgreatgrandchild = node->zero->zero->zero->zero->zero;

这将编译，只要所有那些huffnode后代实际分配并指向正确，它就会起作用。

指针很像JavaScript中的对象引用。它们实际上并不包含数据，只是引用它。请放心，你不是在看无限型。

Answer 8

这被称为自引用结构，它听起来就像它：一个包含对自身的引用的结构。这种情况的常见现象是描述链表节点的结构。每个节点都需要引用链中的下一个节点。

struct linked_list_node { 
    int data; 
    struct linked_list_node *next; // <- self reference 
};

C ++ Struct本身？

8 个答案: