嵌套解除引用的成本可以忽略不计?

时间:2016-01-05 06:31:19

标签: c struct

我有一系列在树上运行的大型递归函数。这些树是使用“多态”定义的,如此

struct foo {
    enum abctype type;
    union {
        struct a ay;
        struct b bee;
        struct c cee;
    }
};

其中struct a ... c是树中的所有节点。树中的每个节点(即,struct a ... c类型的任何对象)指向struct foo的对象。例如:

struct a {
    /* definitions */
    /*...*/
    struct foo *next;
};

正因为如此,即使我的功能没有超出他们的目的,struct解除引用最终也会非常嵌套。

在这种情况下,嵌套的解引用是不可避免的。编写可爱的小包装函数只是为了摆脱->是荒谬的。但是,我听说很多程序员说你不应该超过3-4个解引用或你的“算法需要修复”。

那么,判决是什么?我的代码需要修复吗? 嵌套解除引用效率低下

编辑: 这是我的数据结构更深入的样子(它们不是树,因为我被告知,除非链表==树):

struct a {
    /* definitions */
    /*...*/
    struct foo *longitudinal;
};

struct b {
    /* definitions */
    /*...*/
    struct foo *longitudinal;
    struct b *transverse;
};

struct c {
    /* definitions */
    /*...*/
    struct foo *longitudinal;
    struct c *transverse;
};

基本上,数据结构是这样的,因为它们处理的数据是以这种方式组织的(在我脑海中)。我只是没有看到将其转换为二叉树的方法。

2 个答案:

答案 0 :(得分:3)

单个指针不构成树;它列出了一个清单。树需要至少两个指针。 (您可以找到Wikipedia中描述的例外情况,但您不太可能 - 尽管不是不可能 - 您打算将这样的组织用于您的树结构。)

我认为您的数据组织是......好吧,如果没有错,那么它至少是次优的。你几乎肯定会使用更像这样的结构:

struct tree
{
    struct tree *left;
    struct tree *right;
    enum abctype type;
    union {
        struct a aye;
        struct b bee;
        struct c cee;
    };
};

其中每个单字母结构类型仅包含相关(变体)数据,而不包含任何与树相关的指针:

struct a
{
    /* definitions */
    /* …no struct tree *next; or anything similar… */
};

树遍历现在很好而且统一。将过去必要的东西与现在需要的东西进行比较。鉴于旧的struct foo *tp,您的原始代码(可能)需要做一些可怕的事情:

if (tp->type == TYPE_A)
    process_next(tp->ay.next);
else if (tp->type == TYPE_B)
    process_next(tp->bee.next);
else if (tp->type == TYPE_C)
    process_next(tp->cee.next);
else
    …report error…

(类似于prevleftright指针,或者您用来创建实际树结构的任何其他内容 - 尽管即使作为列表,这不仅仅是一个琐碎凌乱)。

根据修订后的方案,给定struct tree *tp;,您现在只需使用:

process_tree(tp->left);
process_data(tp);
process_tree(tp->right);

数据处理必须处理枚举并访问匿名联合的适当部分。这和以前大致相同(除了你不需要使用树结构指针)。

工作代码

我观察到,由于您没有显示结构abc的数据,因此我不得不猜测什么是合适的。如果这种细节对您很重要,那么在人们回答之前将这些信息放在问题中是很重要的。 (这意味着,部分原因是,现在不要将数据字段添加到结构中 - 您已经有机会指定其中的内容。)

此代码或多或少有效。内存管理没有内存访问错误,至少是测试数据。数据未被释放;这是一个让你玩的练习。并非所有错误检查都存在;这是你的另一项运动。测试并不是那么全面 - 猜猜这意味着什么?

对于您的数据结构应如何工作可能存在一些混淆。我把它解释为:

  • 您可以按任意顺序(A,B或C类型)拥有(纵向)项目列表。这些项目通过struct foo存储,并与匿名工会一起存储。
  • B类物品可以包含更多B类物品的横向清单。
  • C类型的项目可以包含更多C类项目的横向列表。

以下是一些有用的代码:

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

struct a
{
    char name[20];
};

struct b
{
    double x;
    double y;
    struct b *transverse;
};

struct c
{
    int height;
    int width;
    int depth;
    struct c *transverse;
};

enum abctype { TYPE_A, TYPE_B, TYPE_C };

struct foo
{
    struct foo *longitudinal;
    enum abctype type;
    union
    {
        struct a aye;
        struct b bee;
        struct c cee;
    };
};

static struct foo *add_a_long(struct foo *head, const char *name)
{
    struct foo *new_foo = malloc(sizeof(*new_foo));
    if (new_foo != 0)
    {
        strncpy(new_foo->aye.name, name, sizeof(new_foo->aye.name)-1);
        new_foo->aye.name[sizeof(new_foo->aye.name)-1] = '\0';
        new_foo->type = TYPE_A;
        new_foo->longitudinal = head;
    }
    return new_foo;
}

static struct foo *add_b_long(struct foo *head, double x, double y)
{
    struct foo *new_foo = malloc(sizeof(*new_foo));
    if (new_foo != 0)
    {
        new_foo->bee.x = x;
        new_foo->bee.y = y;
        new_foo->bee.transverse = 0;
        new_foo->type = TYPE_B;
        new_foo->longitudinal = head;
    }
    return new_foo;
}

static struct foo *add_c_long(struct foo *head, int height, int width, int depth)
{
    struct foo *new_foo = malloc(sizeof(*new_foo));
    if (new_foo != 0)
    {
        new_foo->cee.height = height;
        new_foo->cee.width = width;
        new_foo->cee.depth = depth;
        new_foo->cee.transverse = 0;
        new_foo->type = TYPE_C;
        new_foo->longitudinal = head;
    }
    return new_foo;
}

static void add_b_trans(struct b *b, double x, double y)
{
    struct b *new_b = malloc(sizeof(*new_b));
    if (new_b != 0)
    {
        new_b->x = x;
        new_b->y = y;
        new_b->transverse = 0;
        while (b->transverse != 0)
            b = b->transverse;
        b->transverse = new_b;
    }
}

static void add_c_trans(struct c *c, int height, int width, int depth)
{
    struct c *new_c = malloc(sizeof(*new_c));
    if (new_c != 0)
    {
        new_c->height = height;
        new_c->width = width;
        new_c->depth = depth;
        new_c->transverse = 0;
        while (c->transverse != 0)
            c = c->transverse;
        c->transverse = new_c;
    }
}

static void print_foo(const char *tag, const struct foo *head)
{
    printf("\n%s:\n", tag);
    while (head != 0)
    {
        switch (head->type)
        {
        case TYPE_A:
            printf("A: %s\n", head->aye.name);
            break;
        case TYPE_B:
            {
            const struct b *bp = &head->bee;
            printf("B-main:  (%f,%f)\n", bp->x, bp->y);
            while ((bp = bp->transverse) != 0)
                printf("B-trans: (%f,%f)\n", bp->x, bp->y);
            }
            break;
        case TYPE_C:
            {
            const struct c *cp = &head->cee;
            printf("C-main:  (%d,%d,%d)\n", cp->height, cp->width, cp->depth);
            while ((cp = cp->transverse) != 0)
                printf("C-trans: (%d,%d,%d)\n", cp->height, cp->width, cp->depth);
            }
            break;
        }
        head = head->longitudinal;
    }
}

int main(void)
{
    struct foo *head = 0;
    head = add_a_long(head, "Caterpillar");
    print_foo("1 item", head);
    head = add_a_long(head, "Ununtrium");
    print_foo("2 items", head);
    head = add_b_long(head, 1.00000, 1.00000);
    head = add_b_long(head, 3.14159, 2.78128);
    print_foo("4 items", head);
    assert(head->type == TYPE_B);
    add_b_trans(&head->bee, 1.2345, 2.3456);
    add_b_trans(&head->bee, 9.8765, 6.5432);
    print_foo("4 items, 2 transverse B", head);
    head = add_a_long(head, "Ununpentium");
    head = add_c_long(head, 3, 4, 5);
    head = add_c_long(head, 5, 12, 13);
    print_foo("6 items", head);
    assert(head->type == TYPE_C);
    add_c_trans(&head->cee, 7, 20, 27);
    add_c_trans(&head->cee, 9, 35, 36);
    head = add_a_long(head, "Ununseptium");
    head = add_a_long(head, "Ununoctium");
    print_foo("Final", head);
    return 0;
}

这是我得到的示例输出:

1 item:
A: Caterpillar

2 items:
A: Ununtrium
A: Caterpillar

4 items:
B-main:  (3.141590,2.781280)
B-main:  (1.000000,1.000000)
A: Ununtrium
A: Caterpillar

4 items, 2 transverse B:
B-main:  (3.141590,2.781280)
B-trans: (1.234500,2.345600)
B-trans: (9.876500,6.543200)
B-main:  (1.000000,1.000000)
A: Ununtrium
A: Caterpillar

6 items:
C-main:  (5,12,13)
C-main:  (3,4,5)
A: Ununpentium
B-main:  (3.141590,2.781280)
B-trans: (1.234500,2.345600)
B-trans: (9.876500,6.543200)
B-main:  (1.000000,1.000000)
A: Ununtrium
A: Caterpillar

Final:
A: Ununoctium
A: Ununseptium
C-main:  (5,12,13)
C-trans: (7,20,27)
C-trans: (9,35,36)
C-main:  (3,4,5)
A: Ununpentium
B-main:  (3.141590,2.781280)
B-trans: (1.234500,2.345600)
B-trans: (9.876500,6.543200)
B-main:  (1.000000,1.000000)
A: Ununtrium
A: Caterpillar

答案 1 :(得分:1)

这种规范的方法是真正使用派生类之类的结构。 I. e。:

struct base {
    enum abctype type;
};

struct a {
    struct base super;
    //whatever other data members `a` happens to have
};

使用这种方法,您可以编写带有struct base*的函数,然后将其转换为其中一个子类。对象的进一步操作使用派生类指针,只有一个->

Btw:如果在struct base中包含函数指针,则可以直接调用派生类的函数(不需要switch)。用于将函数指针分组在它们自己的struct中(实例化为全局表)的加值点,struct base中的单个指针指向正确的函数表。这非常非常接近C ++在幕后所做的事情......

struct base_vtable {
    void (*foo)(int, double);
    int (*bar)(struct base*);
    int (*baz)();
};

struct a_vtable {
    struct base_vtable super;
    double (*bim)();
    dobule (*bam)();
};

struct base {
    struct base_vtable vtable;
};

struct a {
    struct base super;
    //whatever
};

然后,在.c文件中的某个地方:

static struct a_vtable g_a_vtable = {
    .super.foo = &a_foo,
    .super.bar = &a_bar,
    .super.baz = &a_baz,
    .bim = a_bim,
    .bam = a_bam
};

struct a* a_create(...) {
    struct a* me = malloc(sizeof(*me));
    me->super->vtable = g_a_vtable;
    //further initialization
};