Question

我对这个结构有一个问题，很想得到明确的解释。

typedef struct exp{
   int x;
   struct exp *parent;
   struct exp **children;
}

父母和孩子是什么意思？ “parent”是这个结构的数组？孩子们的意思是什么？它是一个数组数组？！我真的无法理解..

最后一件事，如果我正在添加一个元素，它会成为某个父母的特定孩子，我怎样才能到达父母的所有孩子？不应该是一个结构“列表”（使用下一个等...？）？

谢谢!!

Answer 1

此图显示了可能的情况：

a possible scenario

使用此代码和DDD

获取

#include <stdio.h>
#include <stdlib.h>

struct exp{
    int x;
    struct exp *parent;
    struct exp **children;
};

int main ()
{
    struct exp *x = calloc(1, sizeof(x[0]));
    x->x = 42;
    x->parent = calloc(1, sizeof(x[0]));
    x->children = calloc(5, sizeof(x->children[0]));
    x->children[0] = calloc(1, sizeof(x[0]));
    x->children[2] = calloc(1, sizeof(x[0]));
    x->children[3] = calloc(1, sizeof(x[0]));
    x->children[4] = calloc(1, sizeof(x[0]));
    return 0;
}

基本上，children字段是指向struct exp的指针的向量。你决定放在那里的元素和其他东西。

PS：代码只是一个演示，它的质量还不是很好。

Answer 2

它是一个指向指针的指针，在这种情况下，它似乎被用作struct exp的列表。

每个struct exp都有一个引用它的“父”，以及一个指向子列表struct exp的指针。

typedef struct exp{
    int x;
    struct exp *parent;
    struct exp **children;
} element;

// create ROOT elemnt
element * root = (element*) malloc(sizeof(element)); //alocate mem. for 1 element

一旦我们有了“root”，我们就可以添加子代，以下是伪代码

for 1 to 10{
    child = new element;
    child->parent = root;                // tell the child who is his parent
    addToRoot( root , child);            // call a function that inserts elemnts to root

}

所以现在我们应该root包含10个元素的列表：

_______________                                    _______________   
|             | (children)                         |             | - (parent) points to struct exp, root
|     root    | - points to list of struct exp  -> |   child 0   |   
|             |                                    |             | - (children) points to null; // if it's empty  
_______________                                    _______________ 

                                                   _______________  
                                                   |             | - (parent) points to struct exp, root
                                                   |   child 1   |     
                                                   |             | - (children) points to null; // if it's empty 
                                                   _______________ 

                                                   _______________  
                                                   |             | - (parent) points to struct exp, root 
                                                   |   child 2   |      
                                                   |             | - (children) points to null; // if it's empty  
                                                   _______________ 

                                                   _______________  
                                                   |             | - (parent) points to struct exp, root 
                                                   |   child 3   |      
                                                   |             | - (children) points to null; // if it's empty  
                                                   _______________ 

                                                         .
                                                         .
                                                         . 

                                                   _______________  
                                                   |             | - (parent) points to struct exp, root 
                                                   |   child 9   |      
                                                   |             | - (children) points to null; // if it's empty  
                                                   _______________

类似的东西......它有帮助吗？

Answer 3

这是一个指向子节点的指针数组 - 这看起来像某种树结构。

每个节点都有一个父节点，每个节点都有一个或多个子节点。您可以通过

从父母到其中一个孩子旅行

expInstance->children[i];

其中i是表示其中一个子节点的数字。目前还不清楚这个定义有多少个子节点 - 它可能是一个，两个，或一百万个。但鉴于这些信息，你可以循环使用它们。与

一起

for(i=0; i<NUMBER_OF_CHILDREN_NODES;i++){
    expInstance->children[i];
}

如果您事先知道数组的长度或有点奇怪

while(expInstance.children[i++]){
    expInstance->children[i];
}

（有几种不同的聪明方法可以做到这一点，但必须在结构中内置假设，在此数组的最后一个插槽中将有一个空指针，以便终止它。）

Answer 4

如果没有看到更多代码，很难说。你想要实现一棵树吗？从这个定义来看，这对我来说是显而易见的：

parent指向此结构的父节点。
children指向其所有子节点的指针数组。

Answer 5

首先，请记住结构不能包含自身的实例。 IOW，你不能做像

这样的事情

struct exp {
  int x;
  struct exp parent;
  ...
};

这样做的主要原因是，在您尝试声明parent成员时，结构类型不是完整;由于尚未完成对类型的描述，编译器不知道parent成员应该有多大。更不用说parent成员本身会有parent struct exp成员parent，而成员struct exp类型为parent成员{反过来会有struct exp struct exp类型的struct exp成员等等，等等。你最终会得到一个需要无限量存储的对象。

所以你不能拥有struct foo *pf类型的成员。但是，可以对struct bar *pb类型的对象有指针;您可以创建指向不完整类型的指针，并且所有结构指针类型具有相同的大小和表示（IOW，struct foo和struct bar将具有相同的大小，即使{{ 1}}和parent没有）。

所以struct exp成员（可能）只是指向struct exp类型的单个实例（children的每个实例都有一个父实例）。同样地，struct exp成员（可能）是指向atruct exp的单维指针数组（{{1}}的每个实例可以有零个，一个或多个子项）。

C语言中struct的双指针是什么意思

5 个答案: