从内部结构到相同类型的其他结构的指针数组

Question

我遇到了指针问题。我的程序有很多指针，其中大多数都正常工作，但我试图在结构数组中添加一个指针数组，该数组指向同一个结构数组中的不同成员。这应该有点像链表，但也有数组的好处。数组需要动态分配，因为数据是一个结构数组，里面有元素，里面有元素的结构数组，这些元素是基本类型的数组，在运行时之前每个元素的数量都是未知的。我尝试制作静态分配的数组来保存所有数据，但它最终会变成很多兆字节。

我在下面创建了一个精简的测试程序，其中只有我遇到困难的部分。

在groups[0].sub_group[0] = groups[1]; 行中，我试图将指向groups[1] 地址的指针分配给groups[0].sub_group。这确实可以编译，但会出现运行时错误“EXE_BAD_ACCESS”。我认为该行应该是 groups[0].sub_group[0] = &groups[1]; 但这甚至无法编译。

最终我想从函数内部运行它，所以我还需要能够使用指向组的指针进行此分配，例如(*p_groups)[0].sub_group[0] = groups[1];，但这也不起作用。

如果我也可以问一个相关的问题：有什么区别：

(*p_groups)[0].sub_group[0] = groups[1]; 和

p_groups[0]->sub_group[0] = groups[1];?

任何帮助将不胜感激。

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

typedef struct {
    char * text;
    int data_type_count;    // count of elements in data_type_list
    char * bacnet_name;     // string of name
} pup_item_t;

typedef struct pup_group_t pup_group_t;
struct pup_group_t {
    char * title;            // Null Title indicates end of list
    pup_item_t * items;      // array of items
    int item_count;          //count of items
    pup_group_t * sub_group; // array of pointers to associated sub groups
    int sub_group_count;     // count of sub groups
};

typedef pup_group_t * pup_group_array_t;

int main(int argc, const char * argv[])
{
    pup_group_array_t groups = (pup_group_t *)malloc(sizeof(pup_group_t) * 2);
    groups[0].items = (pup_item_t *)malloc(sizeof(pup_item_t)*2);
    groups[1].items = (pup_item_t *)malloc(sizeof(pup_item_t)*2);
    pup_group_array_t * p_groups;
    p_groups = &groups;

    groups[0].items[0].text = strdup("Group 0 Text 0");
    groups[0].items[1].text = strdup("Group 0 Text 1");
    groups[1].items[0].text = strdup("Group 1 Text 0");
    groups[1].items[1].text = strdup("Group 1 Text 1");

    groups[0].sub_group[0]      = groups[1]; // <-- EXE_BAD_ACCESS (code = 1, address = 0x0)
    (*p_groups)[0].sub_group[0] = groups[1]; // <-- EXE_BAD_ACCESS (code = 1, address = 0x0)

    printf("%s \n",groups[0].items[0].text);            // prints "Group 0 Text 0"
    printf("%s \n",groups[1].items[1].text);            // prints "Group 1 Text 1"
    printf("%s \n",groups[0].sub_group->items[1].text); // <-- EXE_BAD_ACCESS (code = 1, address = 0x8)
                                                        // should print "Group 1 Text 1"
    return 0;
}

2014 年 6 月 30 日更新

你在我的示例代码中是对的，我忘了 malloc sub_group。但是在我的实时代码中，我并没有忘记这样做。我的实时代码有几千行，太大了，无法在此处发布。我已经编辑了示例代码以更接近我的实时代码。示例代码现在可以编译并正常工作（据我所知）。但是我的实时代码没有执行。

这是更新后的示例代码：

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


typedef struct {
    char * text;
    int data_type_count;    // count of elements in data_type_list
    char * bacnet_name;     // string of name
} pup_item_t;


typedef struct pup_group_t pup_group_t;
struct pup_group_t {
    char * title;            // Null Title indicates end of list
    pup_item_t * items;      // array of items
    int item_count;          //count of items
    pup_group_t * sub_group; // array of pointers to associated sub groups
    int sub_group_count;     // count of sub groups
};

typedef pup_group_t * pup_group_array_t;

void allocate_groups(pup_group_array_t * p_groups) {
    *p_groups = (pup_group_t *)malloc(sizeof(pup_group_t) * 2);
    p_groups[0]->items = (pup_item_t *)malloc(sizeof(pup_item_t) *2 );
    p_groups[1]->items = (pup_item_t *)malloc(sizeof(pup_item_t) *2 );
    p_groups[0]->sub_group = (pup_group_t *)malloc(sizeof(pup_group_t)* 2);
}

void assign_groups(pup_group_array_t * p_groups) {
    p_groups[0]->items[0].text = strdup("Group 0 Text 0");
    p_groups[0]->items[1].text = strdup("Group 0 Text 1");
    p_groups[1]->items[0].text = strdup("Group 1 Text 0");
    p_groups[1]->items[1].text = strdup("Group 1 Text 1");
    p_groups[0]->sub_group[0] = *p_groups[1];
}

void print_groups(pup_group_array_t * p_groups) {
    printf("%s \n",p_groups[0]->items[0].text);             // prints "Group 0 Text 0"
    printf("%s \n",p_groups[1]->items[1].text);             // prints "Group 1 Text 1"
    printf("%s \n",p_groups[0]->sub_group[0].items[1].text);// prints "Group 1 Text 1"
}

int main(int argc, const char * argv[])
{
    pup_group_array_t groups = NULL;

    allocate_groups(&groups);
    assign_groups(&groups);
    print_groups(&groups);

    return 0;
}

这是我运行时崩溃的实时代码部分：

int allocate_groups_array(char * filename, pup_group_array_t * p_groups, int * p_bacnet_count) {
    int i, size;
    int item[MAX_GROUPS_PER_FILE] = {0};
    int levels[MAX_GROUPS_PER_FILE] = {0};

    int count = scan_pup_file("ct9-103.pup", item, levels, p_bacnet_count);

    *p_groups = (pup_group_t *)malloc(sizeof(pup_group_t)*(count+1));
    for (i = 0; i <= count; i++) {
        size = sizeof(pup_item_t) * (item[i]);
        p_groups[i]->items = (pup_item_t *)malloc(size); // EXC_BAD_ACCESS (code=1, address = 0x18)
        printf("group %d is level %d has %d items with size of %d \n",i,levels[i],item[i], size);
    }

    assign_sub_groups (p_groups, count, item, levels);

    return count;
}

大小和其他变量的值是正确的。但是 malloc p_groups[i]->items = (pup_item_t *)malloc(size); 返回 EXC_BAD_ACCESS。我做错了什么？

** 2014 年 6 月 30 日下午更新 **

这是有人帮助我的工作版本：

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


typedef struct {
    char * text;
    int data_type_count;    // count of elements in data_type_list
    char * bacnet_name;     // string of name
} pup_item_t;


typedef struct pup_group_t pup_group_t;
struct pup_group_t {
    char * title;            // Null Title indicates end of list
    pup_item_t * items;      // array of items
    int item_count;          //count of items
    pup_group_t * sub_group; // array of pointers to associated sub groups
    int sub_group_count;     // count of sub groups
};

//typedef pup_group_t * pup_group_array_t;

pup_group_t * allocate_groups() {
    pup_group_t * p_groups = (pup_group_t *)calloc(sizeof(pup_group_t) , 201);
    p_groups[0].items = (pup_item_t *)malloc(sizeof(pup_item_t) *201 );
    p_groups[1].items = (pup_item_t *)malloc(sizeof(pup_item_t) *201 );
    p_groups[200].items = (pup_item_t *)malloc(sizeof(pup_item_t) *201 );
    p_groups[0].sub_group = (pup_group_t *)malloc(sizeof(pup_group_t *)* 201);
    return p_groups;
}

void assign_groups(pup_group_t * p_groups) {
    p_groups[0].items[0].text = "Group 0 Text 0";
    p_groups[200].items[0].text = "Group 200 Text 1";
    p_groups[1].items[200].text = "Group 1 Text 200";
    p_groups[1].items[200].text = "Group 1 Text 200";
    p_groups[200].items[200].text = "Group 200 Text 200";
    p_groups[0].sub_group[0] = p_groups[200];
}

void print_groups(pup_group_t * p_groups) {
    printf("%s \n",p_groups[0].items[0].text);                // prints "Group 0 Text 0"
    printf("%s \n",p_groups[200].items[0].text);              // prints "Group 200 Text 1"
    printf("%s \n",p_groups[0].sub_group[0].items[200].text); // prints "Group 200 Text 200"

}

int main(int argc, const char * argv[])
{
    pup_group_t * groups = allocate_groups();

    assign_groups(groups);
    print_groups(groups);

    return 0;
}

Answer 1

您尚未为sub_group 成员变量分配任何存储空间。你也需要malloc。

编辑更新代码：对于真正的代码，我担心这可能更难诊断。

看看您是否可以访问items 成员，哦，请稍等。 p_groups 是一个隐藏指针，所以你有一个双指针。它是指向数组的单个指针。所以不应该是：

(*p_groups)[i].items = ...

？我认为你可能正在浪费你的记忆，它可能是 malloc 本身找不到它的元数据。您还可以将强制转换丢失给 malloc，这在 C 中是不必要的。

---

如果我也可以问一个相关的问题：有什么区别：

(*p_groups)[0].sub_group[0] = groups[1]; and

p_groups[0]->sub_group[0] = groups[1]; ?

是的。我注意到你已经怀疑这样的事情了。不同之处在于第一行访问一个指向数组的指针，第二行访问一个指针数组。它们都是双重间接，但它们将数组放置在不同的位置。

如果我们将第二个表达式重写为类似的括号形式，则更容易看出，

(*p_groups[0]).sub_groups[0] = groups[1];

并且后缀运算符先应用，所以相当于this。

(*(p_groups[0])).sub_groups[0] = groups[1];

小型测试可能会产生误导，因为索引 0 会起作用。 *E == *(E+0) == E[0]。并且其他“小”索引可能不会太远超出范围而造成严重的麻烦。但是会发生一些奇怪的事情，你可能已经经历过。更改一行可以解决某些问题，即使更改不应真正更改任何内容，诸如此类的东西，这就是垃圾内存所做的。

如果你能原谅一点 ascii 艺术，

[ -> ]
[ -> ]
[ -> ]
[ -> ]

-> [ ]
   [ ]
   [ ]
   [ ]