C语言 无法在结构中混淆字符串

Question

我的结构看起来像这样：

struct tree{
    char *name;
    int num_subdirs;
    struct tree **subdirs;
}

我收到一个缓冲区，其中包含在缓冲区中序列化的整个树。我正在尝试在此函数中反序列化它：

struct tree *t;
//buffer is filled, received from somewhere else.
int res = deserialize(t, buf); //call function deserialize
//deserialize function
            //buf = {../,2}{sd,0}{|}{sr,1}{sk,0}{|}{|}
   │406     int dfsDeserialize(struct tree *dt, void *buf, int *q){                                                                                                                       │
   │407         char name[MAXPATHLEN];                                                                                                                                                           │
   │408         char delim[3];                                                                                                                                                                   │
   │409         int len, numsubs, i;                                                                                                                                                             │
                                                                                                                                                        │
   │411         sscanf(buf+(*q),"%3s",delim);                                                                                                                                                    │
   │412         if(!strcmp(delim,"{|}")){                                                                                                                                                        │
   │413             (*q)+=3;                                                                                                                                                                     │
   │414             return 1;                                                                                                                                                                    │
   │415         }                                                                                                                                                                                │
   │416         sscanf((buf + (*q)), "{%[^,],%d}%n", name, &numsubs, &len);                                                                                                                      │                                                                                                                                          │
  >│419         int slen = strlen(name);                                                                                                                                                         │
   │420         dt->name = calloc(slen + 1, 1);                                                                                                                                                  │
   │421         dt->subdirs = malloc(numsubs*sizeof(struct tree *));                                                                                                                      │
   │422         strcpy(dt->name, name);                                                                                                                                                          │
   │423         dt->num_subdirs = numsubs;                                                                                                                                                       │
   │424         (*q)+=len;                                                                                                                                                                       │
   │425         for(i = 0; i< numsubs; i++){                                                                                                                                                     │
   │426             dt->subdirs[i] = malloc(sizeof(struct tree));                                                                                                                         │
   │427             dfsDeserialize(dt->subdirs[i], buf, q);                                                                                                                                      │
   │428         }                                                                                                                                                                                │
   │429         return 0;                                                                                                                                                                        │
   │430     }   
                                                                                                                                                                             │

我已经尝试了几种不同的方法来为字符串分配内存，但每次都失败！我不知道为什么 t-> 名称总是0x0。请帮忙。

Answer 1

我认为罪魁祸首是这个

t = malloc(sizeof(sizeof tree));

你可能的意思是

t = malloc(sizeof(struct tree));

您还可以使用更方便的 strdup 在堆上复制字符串

t->name = strdup(name);

Answer 2

C 使用"按值传递"。 将参数传递给函数时，该函数将接收参数的副本。因此，当您有：

struct tree *t;
int res = deserialize(t, buf); //call function deserialize

函数所做的任何操作都不会影响t 。该函数获取 t 的当前值的副本。 （由于t未初始化，这可能会导致未定义的行为）。

相反，您需要告诉函数在内存中t的位置：

int res = deserialize(&t, buf);

该函数可能如下所示：

int deserialize(struct tree **p_t, void *buf)
{
    struct tree *t = malloc(sizeof *t);
    // ... set up t as before
    // tell the caller about what we did
    *p_t = t;
}

---

另一种方法是保持原样deserialize，但完全删除malloc;并要求调用方在调用函数之前分配空间。这更灵活，因为调用方可以选择使用自动分配或动态分配。