[Array of Struct in [Array of Struct in [Array of Struct ]]] 中的结构体动态数组

Question

我想存储 100 名员工。 RollNo，姓名，工资，时间(各种数据，我无法在这里解释，但你可以看下面的代码片段来理解

main() 
{
    struct day {
      int hour[40];
      int min[40];
      int mins[40];
      int rec;
      int totmins;
      int totsal;
      char status;
      int temp;
    };
    struct month {
      struct day * da[31];
    };

    struct year {
      struct month * mn[12];
    };

    struct roll {
      int rn;
      char name[30];
      int salary;
      struct year * yr[25];
    };

所以我动态分配内存

struct day *da[31];
    for(i=0;i<=31;i++)
        {   da[i]=(struct day*)malloc(31 * sizeof *da);
             if( da[i]== NULL )
             {printf("%d Couldn't able to allocate requested memory for day\n",i);getch();exit(0);}
        }

struct month *mn[12];
    for(i=0;i<=12;i++)
        {   mn[i]=(struct month*)malloc( 12 * sizeof *mn);
            if( mn[i]== NULL )
             {printf("%d Couldn't able to allocate requested memory for month\n",i);getch();exit(0);}
        }

struct year *yr[25];
    for(i=0;i<=25;i++)
        {   yr[i]=(struct year*)malloc( 25 * sizeof *yr);
            if( yr[i]== NULL )
                {printf("%d Couldn't able to allocate requested memory for year\n",i);getch();exit(0);}
        }

struct roll *rol[100];
    for(i=0;i<=100;i++)
        {   rol[i]=(struct roll*)malloc(100 * sizeof *rol));
             if( rol[i]== NULL )
             {printf("%d Couldn't able to allocate requested memory for roll\n",i);getch();exit(0);}
        }

但是在我的实际代码中，当我这样做时[考虑 d=27、m=1、y=15 和 i=1]

rol[i] - > yr[y] - > mn[m] - > da[d] - > rec++;

它也会增加剩余成员，即

rol[2] - > yr[y] - > mn[m] - > da[d] - > rec++;
.
.

rol[100] - > yr[y] - > mn[m] - > da[d] - > rec++;

这意味着仅分配中有一些错误...有人可以帮助我吗？

<小时/>

修改后的代码:

    for (i = 0; i < 100; i++) {
      rol[i] = (struct roll * ) malloc(100 * sizeof(struct roll));
      if (rol[i] == NULL) {
        printf("%d Couldn't able to allocate requested memory for roll\n", i);
        getch();
        exit(0);
      }
      for (j = 0; j < 25; j++) {
        rol[i] -> yr[j] = (struct year * ) malloc(25 * sizeof(struct year));
        if (rol[i] -> yr[j] == NULL) {
          printf("%d Couldn't able to allocate requested memory for year\n", i);
          getch();
          exit(0);
        }

        for (k = 0; k < 12; k++) {
          rol[i] -> yr[j] -> mn[k] = (struct month * ) malloc(12 * sizeof(struct month));
          if (rol[i] -> yr[j] -> mn[k] == NULL) {
            printf("%d Couldn't able to allocate requested memory for month\n", i);
            getch();
            exit(0);
          }

          for (l = 0; l < 31; l++) {
            rol[i] -> yr[j] -> mn[k] -> da[l] = (struct day * ) malloc(31 * sizeof(struct day));
            if (rol[i] -> yr[j] -> mn[k] -> da[l] == NULL) {
              printf("%d Couldn't able to allocate requested memory for day\n", l);
              getch();
              exit(0);
            }
          }
        }
      }
    }

但我发现它无法分配内存...

Answer 1

我没有看到您在任何地方初始化任何指针。也许指针初始化是在您没有透露的代码中。

malloc() 返回未初始化的内存。编译器的调试选项可能会初始化从 malloc() 返回的内存。初始化将是某个值或除零以外的值，这可能有助于调试。例如，malloc() 的调试版本可能会分配请求的数量加上 5 个字节。正式分配的数量可能会初始化为 0xa5a，额外的 5 个字节可能会初始化为 0x5a5。这样，通常可以检测到缓冲区的小溢出(小于 5 字节的溢出)。

我认为您的代码显示调用 malloc() 32 + 13 + 26 + 101 = 172 次。但我怀疑你想调用 malloc() 31 * 12 * 25 * 100 = 230,000 次。这是大量的分配和大量的内存。但看起来这就是你的意图。您需要 31 天，因此每个月需要 31 次分配。您需要每年 12 个月，每轮 25 年，以及 100 轮。因此，在我看来，这更像是乘法，而不是 malloc() 调用的加法。

我猜测您尚未初始化指针并且正在使用 malloc() 的调试版本。您未初始化的指针是 101 * 26 = 2626 年指针。也就是说，您的 101 个 rns 中的每一个都有 25 个指针。然后，对于每个年份指针，您有 13 个未初始化的月份指针，等等。

我认为您的代码中发生的情况是处理器正在使用 malloc 内存的调试初始化作为引用的地址。如果内存被初始化为零字节，处理器将检测到 NULL 指针，并且您将收到运行时错误。但是，处理器认为您正在引用有效地址，因此不会提示。结果是，您正在增加一些与您的结构无关的野地址。因为所有结构都使用相同的通配地址，所以看起来好像所有记录都在递增。

你需要做的是为rn分配。然后对于每个 rn，分配 25 年中的每一年。确保每年的 rn POINTS TO 该年度的分配。这就是初始化。然后对于每个 rn 和每年，分配月份，并初始化，以便每个月都指向一个分配......等等。

听起来工作量很大，而且很复杂。因此，如果您有选择，您可能会想出其他解决方案。

要提出另一个解决方案，您可以考虑如何在 Excel 中布置字段(列)。这会让你只剩下一个结构。您可能只需调用一次 malloc()(已经简单多了)。