C动态结构数组[结构数组[结构数组[结构数组]]]

Question

我想存储 100 名员工。 RollNo,Name,Salary,and the time(各种数据，这里我无法解释，但你可以看下面的代码片段

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

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);}
        }

此代码错误。

您正在创建一个包含 31 个元素的结构体数组。 0-30.

循环中的您正在遍历 32 个元素或 0-31。

将 <=31 更改为 <31

Answer 2

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

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

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

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

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

你需要做的是为rn分配。然后对于每个 rn，分配给 25 年中的每一年。确保 rn 的每一年都指向当年的分配。那就是初始化。然后对于每个 rn 和每年，分配月份，并初始化每个月指向一个分配....等

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

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

C动态结构数组[结构数组[结构数组[结构数组]]]

C Dynamic Array of Struct in [Array of Struct in [Array of Struct in [Array of Struct ]]]

c

arrays

pointers

struct

malloc