1

我有一个这样的结构：

typedef struct tree_s{
    struct tree_s *a;
    int b;
}tree_t;

目前，我正在以这种方式进行初始化：

tree_t branch_n = {
    .a = NULL,
    .b = 2
};

tree_t root = {
    .a = (tree_t*) &branch_n, 
    .b = 1
};

现在，让我很恼火的是，我必须在根之前初始化较低的分支，因为完整的结构非常大，分支有自己的分支，使我的代码难以管理。

我想做的是这样的：

tree_t root = {
    .a = 
     //The first branch
     {                 
        .a =
         //Yet another branch 
         { //Since the following is actually an array, I need the 
           // "a" above to point to the first index
             {  
                 .a = NULL,         //Maybe this will have its own branch
                 .b = 3
             },
             {
                 .a = 
                 {
                     .a = NULL,     //And this might even have its own branch
                     .b = 5
                 }
                 .b = 4  
             }
         }
        .b = 2
     }, 
    .b = 1
};

我怎样才能实现这样的初始化？

我想这样做的主要原因是大大增强我的代码的概述，并立即直观地看到“树”的结构。

请注意，从一开始就知道完整“树”的结构，这就是我认为结构不变的原因。但是值 b 可以随时更改。

我对 C 语言很陌生，这是我在 SO 上的第一篇文章，所以请随时编辑或询问我是否无法让自己清楚:)

4

2 回答 2

3

选项 1a - 一个数组

您的“树”结构似乎卡在了相当线性的形状上，但您可以使用数组来解决这个问题：

static const tree_t oak[] =
{
    { .a = &oak[1], .b = 20 },
    { .a = &oak[2], .b = 15 },
    { .a = NULL,    .b = 10 },
};

选项 1b - 从数组构建的树

或者给定一个二叉搜索树结构：

#include <stdio.h>

typedef struct bst_t bst_t;
struct bst_t
{
    int          data;
    const bst_t *left;
    const bst_t *right;
};

static const bst_t bst[] =
{
    { .data = 30, .left = &bst[1], .right = &bst[2] },
    { .data = 10, .left = &bst[3], .right = &bst[4] },
    { .data = 50, .left = &bst[5], .right = &bst[6] },
    { .data =  5, .left = &bst[7], .right = &bst[8] },
    { .data = 20, .left =       0, .right = &bst[9] },
    { .data = 40, .left =       0, .right =       0 },
    { .data = 60, .left =       0, .right =       0 },
    { .data =  2, .left =       0, .right =       0 },
    { .data =  8, .left =       0, .right =       0 },
    { .data = 28, .left =       0, .right =       0 },
};

static void print_in_order(const bst_t *bst)
{
    if (bst != 0)
    {
        printf("[");
        print_in_order(bst->left);
        printf("(%d)", bst->data);
        print_in_order(bst->right);
        printf("]");
    }
}

static void print_tree(const bst_t *bst)
{
    print_in_order(bst);
    putchar('\n');
}

int main(void)
{
    print_tree(&bst[0]);
    return 0;
}

这将产生输出：

[[[[(2)](5)[(8)]](10)[(20)[(28)]]](30)[[(40)](50)[(60)]]]

选项 2a - C99 复合文字

使用 C99 和复合文字，您可以编写：

#include <stddef.h>

typedef struct tree_s{
    struct tree_s *a;
    int b;
}tree_t;

tree_t root2 =
{
    .a = &(tree_t){ .a = NULL, .b = 2 }, .b = 1
};

tree_t root3 =
{
    .a = &(tree_t){ .a = &(tree_t){ .a = NULL, .b = 3 }, .b = 2 }, .b = 1
};

我不确定它是否清晰易读，但可以编译。不过，总的来说，我更喜欢数组表示法。

这是 OP 想要/使用的主要答案。

选项 2b - 尝试将数组初始化失败

尝试调整有问题的修改后的数据结构（请记住，可以使用数据结构创建的“树”只是一个单链表），您几乎可以（但不完全）这样做：

tree_t root4 =
{
    .a = &(tree_t)
    {                 
        .a = (tree_t [])
        { 
            (tree_t){  
                .a = NULL,
                .b = 3
            },
            (tree_t){
                .a = &(tree_t)
                {
                    .a = NULL,
                    .b = 5
                },
                .b = 4  
            },
        },  // Line 47
        .b = 2
    }, 
    .b = 1
};

Mac OS X 10.8.4 上的 GCC (i686-apple-darwin11-llvm-gcc-4.2 (GCC) 4.2.1 (基于 Apple Inc. build 5658) (LLVM build 2336.11.00)) 抱怨：

tree.c:47: error: initializer element is not constant
tree.c:47: error: (near initialization for ‘(anonymous)’)

第 47 行被标记的地方——它是结构数组的结尾。我可能遗漏了一些明显的东西。我确实尝试&(test_t[]){ ... }[0],过，但得到了同样的警告。

我完全不确定您如何判断特定指针是指向数组开头而不是单个tree_t元素的指针，除非您添加另一个字段来指示差异（或者该b字段以某种方式编码以指示是否a是指向单个项目的指针或指向数组的指针）。

于 2013-07-19T09:16:43.937 回答
0

我不认为这段代码：

tree_t root = {
    .a = 
     //The first branch
     {                 
        .a = NULL,       //Maybe another branch instead of NULL
        .b = 2
     }, 
    .b = 1
};

将成功初始化 tree_t 根。

{} 用于初始化结构，而不是指针。但是 root->a 被定义为一个指针。你可能会因此得到编译错误。

可以在上述代码之外定义和初始化分支，并设置指针 root->a 指向它。

于 2013-07-19T09:46:08.750 回答