Question

所以我有一个程序，我正在努力实现一个B树，但我得到一些恼人的编译错误。 B树结构正在运行，但我必须实现一个功能来接受树的顺序作为输入，这会导致一些问题。我遇到的错误是：

Prelim.c：29：38：错误：在'='标记之前预期'：'，'，'，';'，'}'或'属性'

Prelim.c：26：6：错误：灵活的数组成员不在结构

的末尾

受影响的代码是：

struct bTreeNode {                      
    int count;                      
    int value[];                                   // This is line 26

    struct bTreeNode *branch[]; 

    struct bTreeNode *branch[order - 1] = malloc(sizeof(order));   // This is line 29
    int value[order - 1] = malloc(sizeof(order));

};

我的问题分为两部分：第一，为什么会出现这些错误;第二，我如何正确实施这个想法？（如果需要，我可以提供额外的代码，并将订单声明为全局变量）。非常感谢你的帮助！

Answer 1

“为什么会出现这些错误”

在您的代码中，branch是一个bTreeNode指针数组，因此您必须告诉编译器branch的长度。试试这段代码：
```
#define ORDER 10; // hard-coded
struct bTreeNode {
    int count;
    int value[ORDER];
    struct bTreeNode *branch[ORDER - 1]; 
    int value[ORDER - 1];
};
```
您无法在struct bTreeNode定义中使用任何函数。
“我怎样才能正确实现这个想法”

灵活阵列是一个好主意，请尝试struct bTreeNode *branch[0]，然后再分配内存。对不起我丑陋的英语。 ^ _ ^

Answer 2

此声明存在问题

struct bTreeNode *branch[order - 1] = malloc(sizeof(order));

分支指针假设指向（order-1）b-tree节点，但是你正在分配顺序的内存大小（这可能是一个int，所以它可能会返回4个字节）你需要分配btreeNode的内存次序（btree节点的数量*顺序）。试试这个..

struct bTreeNode *branch = malloc(sizeof(struct bTreeNode)*order);

Answer 3

你有一个flexible array member，它位于一个struct数组内，没有编译时已知的维度。您只能拥有其中一个，它应该是struct的最后一个成员：

struct bTreeNode {                      
  int count;                      
  int value[];     // flexible array member
};

^{灵活数组成员是C99}

的高级功能

我猜你希望你的节点有任意数量的值和任意数量的儿子。你需要两个灵活的struct，你应该使用指针。

// forward declarations
struct bTreeNode;
struct bTreeNumber;
struct bTreeSons;

struct bTreeNumber {
  unsigned valcount;
  int value[]; // actual dimension is valcount
};

struct bTreeSons {
   unsigned soncount;
   struct bTreeNode* ptrs[]; // actual dimension is soncount
};

struct bTreeNode {
  struct bTreeNumbers* numbers;
  struct bTreeSons* sons; 
};

这是一个分配空节点的函数，该节点具有给定数量的值和另一个子数

struct bTreeNode *make_node (unsigned nbval, unsigned nbsons)
{
   struct bTreeNumber* pnum = 
      malloc(sizeof(bTreeNumber)+nbval*sizeof(int));
   if (!pnum) { perror("malloc bTreeNumber"); exit(EXIT_FAILURE); };
   pnum->valcount = nbval;
   if (nbval>0) memset (pnum->value, 0, nbval*sizeof(int));
   struct bTreeSon* pson = 
      malloc(sizeof(bTreeSon)+nbsons*sizeof(struct bTreeNode*));
   if (!pson) { perror("malloc bTreeSon"); exit(EXIT_FAILURE); };
   pson->soncount = nbsons;
   for (unsigned ix=0; ix<nbsons; ix++) pson->ptrs[i] = NULL;
   struct bTreNode *pnode = malloc(sizeof(struct bTreeNode));
   if (!pnode) {perror("malloc bTreeNode"); exit(EXIT_FAILURE));
   pnode->numbers = pnum;
   pnode->sons = pson;
   return pnode;
 }

或者你可以决定你的节点有一个指向数字的指针，以及一个灵活的儿子数组成员（反之亦然）

 // alternatively
 struct bTreeNode {
   unsigned nbsons;
   struct bTreeNumber* numbers;
   struct bTreeNode* sons[]; // actual dimension is nbsons
 };

甚至更多“老派”你可以让节点知道儿子的数量和值的数量，并保持指向（堆分配）数组的指针：

 // without flexible members
 struct bTreeNode {
    unsigned nbsons;
    unsigned nbvalues;
    int* pvalues; // point to an array of dimension nbvalues 
    struct bTreeNode** psons; // point to an array of dimension nbsons
 };

在数据结构内创建动态数组时编译C中的错误

3 个答案: