C++ Struktur in sich selbst?

Question

Ich habe diesen Code zu Python zu portieren versucht, aber es ist etwas, was ich in C nicht ganz verstehen ++ (ich weiß, ein bisschen von C++, aber das ist mir schleierhaft):

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

Was ich don Ich verstehe, wie huffnode_s in sich selbst sein kann, ich habe das vorher noch nie gesehen und verstehe es nicht ganz. Was bedeutet das, und wenn jemand kann, was wäre das Python-Äquivalent?

Answer 1

es hat keine Struktur in sich. Es hat einen Zeiger auf diese Struktur.

im Speicher struct huffnode_s wie (32-Bit-Maschine) aussehen:

---

| ------------------ huffnode_s * Null - 4 Bytes -------------- |

| ------------------ huffnode_s * ein - 4 Bytes ---------------- |

| unsigned char val - 1 Byte + 3 Bytes Padding ======= |

| ------------------- float freq - 4 Bytes --------------------- ---- |

Diese Größen würden Maschine zu Maschine variieren, und wie es im Speicher aussieht, wird vom Compiler entschieden.

Answer 2

huffnode_s ist nicht in sich selbst, nur Zeiger-huffnode_s da drin sind. Da ein Zeiger von bekannter Größe ist, ist das kein Problem.

Answer 3

Wie andere bemerkt haben, sind die Verweise auf sich selbst einfach Zeiger auf andere Instanzen dieser Struktur.

Die Zeiger innerhalb der Struktur würden es ermöglichen, Instanzen als verknüpfte Liste miteinander zu verbinden.

Answer 4

Dies.

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 

Sie können dann Ihre verschiedenen C-Funktionen als Methoden dieser Klasse umgestalten.

Oder vielleicht dies.

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

Wenn Sie wollen, dass Ihre C-Funktionen Funktionen bleiben.

Das ist es.

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

Das ist alles, was erforderlich ist.

Answer 5

(struct huffnode_s *) deklariert einen Zeiger auf eine andere Struktur, die dieselben Variablen enthält wie die Struktur, in der sie deklariert ist. Siehe this question.

Answer 6

Dies ist ein Zeiger auf einen Huffnode innerhalb eines Huffnode.Was dies bedeutet, ist, dass man sagen kann:

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

Dies kompiliert, und es wird funktionieren, solange diese alle huffnode Abkömmlinge tatsächlich zugeordnet sind und darauf richtig.

Zeiger sind Objektverweisen in JavaScript sehr ähnlich. Sie enthalten keine Daten, sie beziehen sich nur darauf. Sei versichert, dass du nicht auf einen unendlichen Typ schaust.

Answer 7

Carl Antwort hinzuzufügen, ist die gleiche Sache in C++ auch möglich:

class Foo { 
public: 
    Foo() {} 

    Foo *anotherFoo; 
}; 

(Beachten Sie die obige Klasse ist albern, aber der Punkt ist, dass Sie einen Zeiger in einer Klasse haben können, die von der ist Klassentyp)

Answer 8

Dies ist bekannt als eine selbstreferentielle Struktur und es ist genau, was es klingt: eine Struktur, die einen Verweis auf sich selbst enthält. Ein häufiges Vorkommen davon ist in einer Struktur, die einen Knoten für eine verknüpfte Liste beschreibt. Jeder Knoten benötigt einen Verweis auf den nächsten Knoten in der Kette.