如何在另一个结构中访问双指针结构

如何解决如何在另一个结构中访问双指针结构

我无法访问结构中的双指针结构。

typedef struct monster
{
    char *name;
    char *element;
    int population;
} monster;

typedef struct region
{
    char *name;
    int nmonsters;
    int total_population;
    monster **monsters;
} region;


region **
readRegion (FILE * infile,int *regionCount)
{
    
    region **temp;
    char garbage[50];
    char garbage2[50];
    
    char rName[50];
    int monsterNum;
    
    fscanf (infile,"%d %s",regionCount,garbage);
    temp = malloc (*regionCount * sizeof (region *));
    
    for (int i = 0; i < *regionCount; i++)
    {
        fscanf (infile,"%s%d%s",rName,&monsterNum,garbage2);
        temp[i] = createRegion (inFile,monsterNum);
    }
    return temp;
}

region *
createRegion (FILE * inFile,char *rName,int nMonsters)
{
    region *r = malloc (sizeof (region));
    char rMonster[50];
    int rLength;
    r->name = malloc ((strlen (rName) + 1) * sizeof (char));
    strcpy (r->name,rName);
    r->nmonsters = nMonsters;
    
    for (int i = 0; i < nMonsters; i++)
    {
        r->monsters.name = (nMonsters * sizeof (r->monsters.name));
        fscanf (in,"%s",rMonster);
        
        r->monsters.name = malloc ((strlen (rMonster) + 1) * sizeof (char));
        strcpy (r->monsters.name,rMonster);
    }
    return r;
}

希望我的代码是可读的，在这里您可以了解我试图与我的区域结构中的monster ** monsters指针进行关联的内容。对于如何在结构内访问和使用双结构指针的任何解释，都将有所帮助。

解决方法

我已经尝试清理并重新解释您的createRegion，使其读起来更像传统的C：

region* createRegion(FILE * inFile,char *rName,int nMonsters) {
  region *r = malloc(sizeof(region));
  char buffer[1024];

  r->name = strdup(rName);

  r->nmonsters = nMonsters;

  r->monsters = calloc(nMonsters,sizeof(monster*));

  for (int i=0; i < nMonsters; i++) {
    // Allocate a monster
    monster *m = malloc(sizeof(monster));

    fscanf(in,"%s",buffer);

    m->name = strdup(buffer);
    m->element = NULL; // TBD?
    m->population = 1; // TBD?

    // Put this monster in the monsters pointer array
    r->monsters[i] = m;
  }
  return r;
}

这里的关键是您必须分配怪物。这里是单独完成的，但是您也可以将其分配为平板：

region* createRegion(FILE * inFile,int nMonsters) {
  region *r = malloc(sizeof(region));
  char buffer[1024];

  r->name = strdup(rName);

  r->nmonsters = nMonsters;

  // Make a single allocation,which is usually what's returned from
  // C functions that allocate N of something
  monsters* m = calloc(nMonsters,sizeof(monster));

  // Normally you'd see a definition like m in the region struct,but
  // that's not the case here because reasons.

  r->monsters = calloc(nMonsters,sizeof(monster*));

  for (int i=0; i < nMonsters; i++) {
    fscanf(in,buffer);

    m[i].name = strdup(buffer);
    m[i].element = NULL; // TBD?
    m[i].population = 1; // TBD?

    // Put this monster in the monsters pointer array
    r->monsters[i] = &m[i];
  }

  return r;
}

请注意，我已经通过一个简单的strlen调用切换出了高度古怪的基于strdup的代码。看到sizeof(char)被使用也很奇怪，因为在可能与之连接的任何计算机上，无论是嵌入式微控制器还是精美的大型机，都会为1。

由于您询问有关访问结构内部的双指针的问题，我认为您的问题主要是关于此功能的：

region *
createRegion (FILE * inFile,int nMonsters)
{
    region *r = malloc (sizeof (region));
    char rMonster[50];
    int rLength;
    r->name = malloc ((strlen (rName) + 1) * sizeof (char));
    strcpy (r->name,rName);
    r->nmonsters = nMonsters;

[A点]

到目前为止，一切都很好，但是在这里您开始失控了。

    for (int i = 0; i < nMonsters; i++)
    {
        r->monsters.name = (nMonsters * sizeof (r->monsters.name));

继续。 r->monsters的类型为monster **，但是您试图像访问monster一样访问它。此外，r->monsters从未分配任何值，因此几乎没有可以安全使用的值。

我认为这个主意必须是使r->monsters指向动态分配的monster *数组，并且循环分配并初始化怪物，并将指向它们的指针写入数组。

然后，您需要为数组分配空间，但是您只需要或想要分配一次数组。在循环之前，在上方的A点执行以下操作：

      r->monsters = malloc(nMonsters * sizeof(*r->monsters));  // a monster **

然后，在循环内，您需要为一个怪物分配空间，并为其分配一个指向您的数组的指针：^*

    r->monsters[i] = malloc(sizeof(*r->monsters[i]));  // a monster *

然后，要访问实际的monster对象，您需要推导并使用直接成员选择运算符（.）...

    (*r->monsters[i]).name = /* ... */;

...或使用间接成员选择运算符（->）...

    r->monsters[i]->name = /* ... */;

。两者是等效的，但是大多数C程序员似乎更喜欢后者。

但是，在这一点上，我注意到在循环的主体中，您似乎正在尝试为怪物的name成员进行两个单独的分配。这没有意义，而且第一次尝试肯定没有意义，因为您似乎正在尝试为指针分配数字。

        fscanf (in,rMonster);
        
        r->monsters.name = malloc ((strlen (rMonster) + 1) * sizeof (char));
        strcpy (r->monsters.name,rMonster);

然后，使用上述内容，并利用sizeof(char)根据定义为1的事实，看来您想要的是

        // ...

        r->monsters[i]->name = malloc(strlen(rMonster) + 1);
        strcpy (r->monsters[i]->name,rMonster);

最后

    }
    return r;
}

请注意，与类型monster **的两个间接级别相对应，每次通过r->members访问单个怪物属性都需要两个级别的推断。在上面的表达式中，一个由索引运算符[]提供，另一个由间接成员访问运算符->提供。

^*或者，您可以在循环之前和循环内一次为所有怪物分配空间，只需初始化它们和指向它们的指针数组即可。 monster **的使用建议了个体分配方法，但是选择哪种方法取决于它们的使用方式。这两个选项基本上可以互换，但不能完全等同。

如何在另一个结构中访问双指针结构

如何解决如何在另一个结构中访问双指针结构

解决方法

相关推荐