0

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

"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;
}
4

2 回答 2

0

您没有为 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 个水果类别。数组和链表都对多次添加相同的结构没有任何限制。这意味着每次您都需要检查整个列表以查看是否需要添加新结构。

出于这个原因，我当然会将类别和产品数组都制作成映射名称 - > 结构的哈希表（或在某些语言中称为字典）。这将加快您的搜索速度，因为您不必每次都搜索整个数据集，并且会阻止您多次添加相同的结构。

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

于 2013-03-19T01:25:00.077 回答
0

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

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增加数组的大小，并更新其计数。

把这些东西都放在函数里，代码也不会太复杂。

于 2013-03-19T02:09:25.873 回答