Question

我意识到这听起来像是一个重复的问题，它可能是，但我一直在寻找几天。我乱糟糟的代码就是：

node* deSerialize(FILE *fp) {
    char key[20];
    char value[MAXSIZE];
    node *n = NULL;
    while (fscanf(fp, " %[^*]*%[^*]* ",key,value)==2) {
        if (n) {
            n = add_node(n,key,value);
        }
        else{
            n = new_node(key,value);
        }
    }
    return n;
}

但是当我将反序列化结构保存回磁盘时，它只保存最后一个键/值。像这样：

test*value* test*value* test*value* test*value* test*value* test*value* test*value* test*value*

序列化结构看起来像这样：

key1*value1* key2*value2* key3*value3* key4*value4* key5*value5* key6*value6* key7*value7* test*value*

据我所知，字符串指针（或数组指针，不确定该怎么称呼它）key和value正在更新，因此它们最终都指向同一个东西，但是我怎么能阻止它？

为完整起见，以下是其他相关功能：

void serialize(FILE *fp, node *n) {
    node *j = n;
    while (j) {
        while(j->left) {
            serialize(fp,j->left);
            j->left=NULL;
        }
        while(j->right) {
            serialize(fp,j->right);
            j->right=NULL;
        }

        fprintf(fp,"%s*%s* ",j->key,j->value);
        j=NULL;
    }
}

node* new_node(char *key, char *value) {
    struct node* result = malloc(sizeof(struct node));
    memset(result, 0, sizeof(struct node));
    result->key = key;
    result->hash = hash(key);
    result->value = value;
    result->left = result->right = NULL;
    return result;
}

node* add_node(node* tree, char *key, char *value ) {
    unsigned long h = hash(key);
    if (tree==NULL)
        tree=new_node(key,value);
    if (h<tree->hash)
        tree->left = add_node(tree->left,key,value);
    if (h>tree->hash)
        tree->right = add_node(tree->right,key,value);
    return tree;
}

Answer 1

But when I save the deserialized structure back to a disk, it only saves the last key/value.

如果您不知道之前的行数，那么您在循环中存储相同的变量，并在每次迭代时保留malloc。

有关使用malloc动态分配的更多细节仍然存在太棒了但是

像这样（未经测试）：

   char *key;
   char *value;
   node *n = NULL;

   while (1) {
       key = malloc(20);
       if (key == NULL) {
           /* raise error */
       }
       value = malloc(MAX_SIZE);
       if (value == NULL) {
           /* raise error */
       }
       if (fscanf(fp, " %[^*]*%[^*]* ", key, value) != 2) {
           free(key);
           free(value);
           break;
       }
       if (n) {
           n = add_node(n, key, value);
       } else {
           n = new_node(key, value);
       }
   }

您必须free这些值（可能在tree_destroy()函数中）以避免内存泄漏。

Answer 2

您需要为结构中的重复字符串动态分配内存。目前，您覆盖之前的数据，因为所有节点都引用相同的数组。

你不想要创建一个二维数组，因为从函数返回时，你的节点将引用已经清理过的堆栈上的内存。（本地数组放在堆栈上，并在函数返回时被删除。）正确的方法是使用动态内存分配。

以下是使用动态分配保存数据的方法：

node* new_node(char *key, char *value) {
    struct node* result = malloc(sizeof(struct node));
    memset(result, 0, sizeof(struct node));

    result->key = strdup(key); //DUPLICATE STRING

    result->hash = hash(key);
    result->value = value;
    result->left = result->right = NULL;
    return result;
}

您不必事先知道字符串的大小。此外，您需要free()通过实施destroy_node()功能分配的内存：

void destroy_node(node *n) {
    if (n != NULL) {
        free(n->key);
        free(n);
    }
}

如何循环浏览文本，将文件中的数据读入c中的多个变量？

2 个答案: