Question

我正在尝试创建以下数组：

"Fruits", 25, {
    {"Apple", 2}, 
    {"Grapes", 13}, 
    {"Melon", 10}
}
"Meats", 40, {
     {"Beef", 9}, 
     {"Chicken", 27}, 
     {"Pork", 4}
 }

...

感觉就像到目前为止我做的更优雅。任何关于如何在给定输入结构的情况下更有效地创建此结构的反馈/样本将不胜感激。

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

typedef struct Product {
    char *name;
    int qty;
} Prods;

typedef struct Category {
    char *name;
    int qty;
    int prods_count;
    Prods *prod;
} Cats;

typedef struct Inventory {
    Cats *cat;
    int cats_count;
} Inv;

struct tmp_input {
    char name[12];
    int qty;
    char cat[12];
};

// return index if found
int in_array(Inv *inv, char *k) {
    int i;
    if (inv->cats_count == 0)
        return -1;
    for (i = 0; i < inv->cats_count; i++) {
        if (strcmp (k, inv->cat[i].name) == 0) return i;
    }
    return -1;
}

int main () {
    int i, j, exists = 0;
    // temp struct.
    struct tmp_input items[] = {
        {"Apple", 2, "Fruit"}, {"Coke", 10, "Drink"},   {"Pork", 4, "Meat"},
        {"Beef", 9, "Meat"},   {"Chicken", 27, "Meat"}, {"Melon", 10, "Fruit"},
        {"Tea", 3, "Drink"},   {"Coffee", 20, "Drink"}, {"Grapes", 13, "Fruit"}
    };

    size_t len = sizeof (items) / sizeof (struct tmp_input);

    Inv *inven = malloc(sizeof(Inv));
    inven->cats_count = 0;
    inven->cat = calloc(1, sizeof(Cats));

    for (i = 0; i < len; i++) {
        exists = in_array(inven, items[i].cat);
        // category does not exist
        if (exists == -1) {
            inven->cat = realloc(inven->cat, sizeof(Cats) * (inven->cats_count + 1));
            inven->cat[inven->cats_count].name = strdup(items[i].cat);
            inven->cat[inven->cats_count].qty += items[i].qty;

            inven->cat[inven->cats_count].prods_count = 1;
            inven->cat[inven->cats_count].prod = calloc (1, sizeof (Prods));
            inven->cat[inven->cats_count].prod->name = strdup (items[i].name);
            inven->cat[inven->cats_count].prod->qty = items[i].qty;
            inven->cats_count++;
        }
        // category found
        else  {
            inven->cat[exists].qty += items[i].qty;

            int size = inven->cat[exists].prods_count + 1;
            inven->cat[exists].prod = realloc(inven->cat[exists].prod, sizeof(Prods) * (size));
            inven->cat[exists].prod[size - 1].name = strdup (items[i].name);
            inven->cat[exists].prod[size - 1].qty= items[i].qty;
            inven->cat[exists].prods_count++;
        }
    }

    for (i = 0; i < inven->cats_count; i++) {
        printf("%3d %s\n", inven->cat[i].qty, inven->cat[i].name);
        for (j = 0; j < inven->cat[i].prods_count; j++) {
            printf("%3d %s\n", inven->cat[i].prod[j].qty, inven->cat[i].prod[j].name);
        }
    }

    return 0;
}

Answer 1

您没有为Prod阵列分配任何内存。

像

这样的东西

...

if (exists == -1) {
    inven->cat = realloc(inven->cat, sizeof(Cats) * (inven->cats_count + 1));
    inven->cat[inven->cats_count].name = items[i].cat;
    inven->cat[inven->cats_count].qty += items[i].qty;

    // Allocate memory for 1 product
    inven->cat[inven->cats_count].prods_count = 1;
    inven->cat[inven->cats_count].prod = malloc (sizeof (Prods));

    // Now allocate space and copy the name
    inven->cat[inven->cats_count].prod->name = strdup (items[i].name + 1);

    inven->cats_count++;
}
...

我会留给您处理一个类别中有多个产品的情况，您需要再次重新分配内存。

另一个错误是您需要分配和复制类别名称

inven->cat[inven->cats_count].name = items[i].cat;

应替换为

inven->cat[inven->cats_count].name = strdup (items[i].cat);

这是因为items数组在此函数之外不存在，所以如果你只是这样做

inven->cat[inven->cats_count].name = items[i].cat;

然后在你离开这个函数后，invent->cat[inven->cats_count].name将指向垃圾记忆。

最后的建议是将每个结构拆分成一个处理它的创建的函数，只是为了清理代码。

---编辑以添加对抽象数据类型的评论

如果您拥有通过索引访问的数据，则数组非常有用。如果您不知道所需项目的索引（如本例所示），则数组不太有用。

与其他评论不同，我认为使用链接列表并不能为您提供任何有用的信息。当您需要顺序遍历所有项目时，链接列表非常有用，而无需真正关心它们在列表中的位置。在我看来，像你这样的系统最常见的用例是搜索：我们有库存水果吗？将10个可口可乐案例添加到库存......那些事情。

此外，您只需要为每个类别/产品指定一个条目。您不希望数据中包含3个Fruit类别。数组和链表对多次添加相同结构没有任何限制。这意味着每次您需要检查整个列表以查看是否需要添加新结构。

出于这个原因，我肯定会将类别和产品数组分别设置为哈希表（或称为某些语言的字典），这些哈希表映射了名称 - ＆gt;结构体。这将加快您的搜索速度，因为您不必每次都搜索整个数据集，并且会阻止您多次添加相同的结构。

关于Hashtables的维基百科文章：http://en.wikipedia.org/wiki/Hashtable

Answer 2

以下是如何动态设置结构的示例（比链表更简单，但不灵活）。

typedef struct Product {
   char *name;
   int qty;
} Prods;

typedef struct Category {
   char *name;
   int qty;
   int prods_count;
   Prods *prod;      // dynamic array of Products
} Cats;

结构原样。

   struct Category categ[10];

任意数量的类别，现在将categ[0]用于'水果'。

接下来动态创建一个包含10个产品结构的数组：

   Prods *prod_array = malloc(sizeof(Prods) * 10); // i.e. prod_array[0] to [9]

现在只需将数组存储在类别结构中：

   categ[0].prod = prod_array;
   categ[0].prods_count = 10;

如果您需要访问产品名称，则只需：categ[i].prod[j].name

现在，如果您需要另外10个产品，您可以使用realloc来增加数组的大小，并更新其数量。

将所有这些东西放在函数中，代码不是太复杂。

在C中创建嵌套结构的动态自定义数组

2 个答案: