C 结构数组的动态内存分配

所以我一直在做我的一个小项目，我被困在这个阶段。我不断地犯错误，我越来越绝望。我有两个结构

typedef struct {
    float time;
}Race;

typedef struct {
    char DriverName[50];
    int NoRaces;
    Race *races;
}Driver;

我必须为单个驱动程序分配内存，然后在为每个驱动程序分配了比赛次数后，为一组驱动程序分配内存。这是到目前为止我的代码

Driver *allocDriver(int noRaces) {
    Driver *driver;
    driver = (Driver *)malloc(sizeof(Driver));
    driver->NoRaces = noRaces;
    driver->races = (Race *)malloc(sizeof(Race));       

    return driver;}


Driver **allocDrivers(int driversNo, int *driversRacesNo) {
    int i;
    Driver **drivers;
    drivers = (Driver **)malloc(driversNo * sizeof(Driver *));
    for(i = 0; i < driversNo; i++)
        drivers[i] = allocDriver(driversRacesNo[i]);

    return drivers;}

Driver*allocDriver（int-noRaces）{
司机*司机；
driver=（driver*）malloc（sizeof（driver））；
驱动程序->NoRaces=NoRaces；
车手->赛车=（赛车*）马洛克（赛道）；
返回驱动程序；}
驱动程序**所有驱动程序（int driversNo，int*driversRacesNo）{
int i；
司机**司机；
drivers=（drivers**）malloc（driversNo*sizeof（drivers*）；
对于（i=0；i

虽然我不确定，因为我不知道你如何从

主

中调用这些，也不知道作业的内容；我怀疑您需要更改以下行

driver->races = (Race *)malloc(sizeof(Race));

比如：

---

例如，您的代码将5存储为比赛数，但没有为

struct Race

分配5个内存空间（我认为，这个struct用于比赛结果）；现在，它只分配了一个mem宽度的

struct Race

，虽然我不确定，因为我不知道您如何从

main

调用它们，也不知道分配的内容；我怀疑您需要更改以下行

driver->races = (Race *)malloc(sizeof(Race));

比如：

---

例如，您的代码将5存储为比赛数，但没有为

struct Race

分配5个内存空间（我认为，这个struct用于比赛结果）；现在，它只分配一个mem宽度的

struct Race

这里有一个关于结构表分配的“扩展”但简单的例子，在ubuntu 18.04上编译。希望它能够自我解释和说明。为了将来的发展和实践，尝试使用链表代替数组

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct sRace {
    float time;
}Race;

typedef struct sDriver {
    char DriverName[50];
    int NoRaces;
    Race *races;
}Driver;


typedef struct sDriversTable {
    int numdrivers;
    Driver** drivers;
} DriversTable;



Driver *allocDriver(char* name, int numraces)
{
    Driver *driver = calloc(1, sizeof(Driver));
    driver->NoRaces = numraces;
    strcpy(driver->DriverName, name);
    driver->races = calloc(numraces,sizeof(Race));
    return driver;
}

DriversTable* allocDriversTable(int numdrv)
{
     DriversTable* dt = calloc(1,sizeof(DriversTable));
     dt->numdrivers = numdrv;
     dt->drivers = calloc(dt->numdrivers, sizeof(Driver*));
    return dt;
}


void addDriver(DriversTable* drv, char* name, int numraces)
{
    for(int i = 0; i < drv->numdrivers; i++)
    {
        if( drv->drivers[i]  == NULL)
        {
            drv->drivers[i] = allocDriver(name, numraces);
            break;
        }
    }
}

void setDriverTimeForTheRace(DriversTable* drv, char* name, int raceindex, float time)
{

    for(int i = 0; i < drv->numdrivers; i++)
    {
        if( !strcmp(drv->drivers[i]->DriverName,name) )
        {
            if( raceindex < drv->drivers[i]->NoRaces )
            {
               drv->drivers[i]->races[raceindex].time = time;
            }
            else
            {
                printf("invalid race index. %d, (max. for the driver %s is %d\n",raceindex,drv->drivers[i]->DriverName, drv->drivers[i]->NoRaces -1);
            }
            break;
        }
    }
}

void printDriversTable(DriversTable* drv)
{
    for(int i = 0; i < drv->numdrivers; i++)
    {
        if( drv->drivers[i]  != NULL)
        {
            printf("Driver:%s, Races: %2d\n", drv->drivers[i]->DriverName, drv->drivers[i]->NoRaces);
            for(int j = 0; j < drv->drivers[i]->NoRaces; j++)
            {
                if(drv->drivers[i]->races[j].time > 0.0 )
                    printf("{%4.2f}", drv->drivers[i]->races[j].time);
                else
                    printf("{%4s}", "n/a");
            }
            printf("\n");
        }
    }
}

void ReleaseResources(DriversTable** dt)
{
    DriversTable* drv = *dt;
    if( drv == NULL)
    {
      printf("nothing to release!\n");
      return;
    }
    for(int i = 0; i < drv->numdrivers; i++)
    {
        if( drv->drivers[i]  != NULL)
        {
            free(drv->drivers[i]->races);
            drv->drivers[i]->races = NULL;
            free(drv->drivers[i]);
            drv->drivers[i]=NULL;
        }
    }

    free(drv->drivers);
    drv->drivers = NULL;
    free(drv);
    *dt = NULL;
    printf("released!\n");
}

int main()
{
    DriversTable *drv = allocDriversTable(10);
    addDriver(drv,"Emerson", 6);
    setDriverTimeForTheRace(drv,"Emerson",1, 34.5);
    setDriverTimeForTheRace(drv,"Emerson",2, 33.6);
    setDriverTimeForTheRace(drv,"Emerson",7, 34.5);
    addDriver(drv,"Lake",7);
    setDriverTimeForTheRace(drv,"Lake",3, 21.5);
    setDriverTimeForTheRace(drv,"Lake",5, 22.6);
    setDriverTimeForTheRace(drv,"Lake",7, 23.5);
    addDriver(drv,"Palmer",8);
    setDriverTimeForTheRace(drv,"Palmer",4, 21.5);
    setDriverTimeForTheRace(drv,"Palmer",6, 22.6);
    setDriverTimeForTheRace(drv,"Palmer",7, 23.5);
    printDriversTable(drv);
    ReleaseResources(&drv);
    ReleaseResources(&drv);
    return 0;
}

#包括
#包括
#包括
类型定义结构空间{
浮动时间；
}种族；
类型定义结构驱动程序{
char DriverName[50]；
国际诺拉塞斯；
种族*种族；
}司机；
typedef结构sDriversTable{
国际努姆德里弗斯；
司机**司机；
}司机台；
驱动程序*allocDriver（字符*名称，整数）
{
Driver*Driver=calloc（1，sizeof（Driver））；
驱动程序->NoRaces=numraces；
strcpy（driver->DriverName，name）；
车手->比赛=calloc（numraces，sizeof（比赛））；
返回驱动器；
}
DriversTable*allocDriversTable（int numdrv）
{
DriversTable*dt=calloc（1，sizeof（DriversTable））；
dt->numdrivers=numdrv；
dt->drivers=calloc（dt->numdrivers，sizeof（Driver*）；
返回dt；
}
void addDriver（DriversTable*drv，char*name，int numraces）
{
对于（int i=0；inumdrivers；i++）
{
如果（drv->drivers[i]==NULL）
{
drv->drivers[i]=allocDriver（名称、数量）；
打破
}
}
}
void setDriverTimeForTheRace（DriversTable*drv，char*name，int raceindex，浮点时间）
{
对于（int i=0；inumdrivers；i++）
{
如果（！strcmp（drv->drivers[i]->DriverName，name））
{
if（赛车索引drivers[i]->NoRaces）
{
drv->驾驶员[i]->比赛[raceindex]。时间=时间；
}
其他的
{
printf（“无效的竞赛索引。%d，（驱动程序%s的最大值为%d\n）”，竞赛索引，drv->drivers[i]->DriverName，drv->drivers[i]->NoRaces-1；
}
打破
}
}
}
无效打印驱动器表（驱动器表*drv）
{
对于（int i=0；inumdrivers；i++）
{
如果（drv->drivers[i]！=NULL）
{
printf（“驱动程序：%s，种族：%2d\n”，drv->drivers[i]->DriverName，drv->drivers[i]->NoRaces）；
对于（int j=0；jdrivers[i]->NoRaces；j++）
{
如果（drv->drivers[i]->races[j].时间>0.0）
printf（“{%4.2f}”，drv->drivers[i]->races[j].时间）；
其他的
printf（“{%4s}”，不适用）；
}
printf（“\n”）；
}
}
}
无效释放资源（驱动器表**dt）
{
驱动器表*drv=*dt；
如果（drv==NULL）
{
printf（“无需发布！\n”）；
返回；
}
对于（int i=0；inumdrivers；i++）
{
如果（drv->drivers[i]！=NULL）
{
免费（drv->驾驶员[i]->比赛）；
drv->drivers[i]->races=NULL；
免费（drv->drivers[i]）；
drv->drivers[i]=NULL；
}
}
免费（drv->司机）；
drv->drivers=NULL；
免费（drv）；
*dt=零；
printf（“已发布！\n”）；
}
int main（）
{
DriversTable*drv=allocDriversTable（10）；
ADDRIVER（drv，“艾默生”，6）；
setDriverTimeForTheRace（drv，“Emerson”，1，34.5）；
setDriverTimeForTheRace（drv，“Emerson”，2，33.6）；
setDriverTimeForTheRace（drv，“Emerson”，7，34.5）；
ADDRIVER（drv，“湖”，7）；
setDriverTimeForTheRace（drv，“湖”，3，21.5）；
setDriverTimeForTheRace（drv，“湖”，5，22.6）；
setDriverTimeForTheRace（drv，“湖”，7，23.5）；
addDriver（drv，“Palmer”，8）；
setDriverTimeForTheRace（drv，“Palmer”，4，21.5）；
setDriverTimeForTheRace（drv，“Palmer”，6，22.6）；
setDriverTimeForTheRace（drv，“Palmer”，7，23.5）；
printDriversTable（drv）；
释放资源（&drv）；
释放资源（&drv）；
返回0；
}

这是一个关于结构表分配的“扩展”但简单的示例，在ubuntu 18.04上编译。希望它能够自我解释并足够说明。对于未来的开发和实践，尝试使用链表代替数组

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct sRace {
    float time;
}Race;

typedef struct sDriver {
    char DriverName[50];
    int NoRaces;
    Race *races;
}Driver;


typedef struct sDriversTable {
    int numdrivers;
    Driver** drivers;
} DriversTable;



Driver *allocDriver(char* name, int numraces)
{
    Driver *driver = calloc(1, sizeof(Driver));
    driver->NoRaces = numraces;
    strcpy(driver->DriverName, name);
    driver->races = calloc(numraces,sizeof(Race));
    return driver;
}

DriversTable* allocDriversTable(int numdrv)
{
     DriversTable* dt = calloc(1,sizeof(DriversTable));
     dt->numdrivers = numdrv;
     dt->drivers = calloc(dt->numdrivers, sizeof(Driver*));
    return dt;
}


void addDriver(DriversTable* drv, char* name, int numraces)
{
    for(int i = 0; i < drv->numdrivers; i++)
    {
        if( drv->drivers[i]  == NULL)
        {
            drv->drivers[i] = allocDriver(name, numraces);
            break;
        }
    }
}

void setDriverTimeForTheRace(DriversTable* drv, char* name, int raceindex, float time)
{

    for(int i = 0; i < drv->numdrivers; i++)
    {
        if( !strcmp(drv->drivers[i]->DriverName,name) )
        {
            if( raceindex < drv->drivers[i]->NoRaces )
            {
               drv->drivers[i]->races[raceindex].time = time;
            }
            else
            {
                printf("invalid race index. %d, (max. for the driver %s is %d\n",raceindex,drv->drivers[i]->DriverName, drv->drivers[i]->NoRaces -1);
            }
            break;
        }
    }
}

void printDriversTable(DriversTable* drv)
{
    for(int i = 0; i < drv->numdrivers; i++)
    {
        if( drv->drivers[i]  != NULL)
        {
            printf("Driver:%s, Races: %2d\n", drv->drivers[i]->DriverName, drv->drivers[i]->NoRaces);
            for(int j = 0; j < drv->drivers[i]->NoRaces; j++)
            {
                if(drv->drivers[i]->races[j].time > 0.0 )
                    printf("{%4.2f}", drv->drivers[i]->races[j].time);
                else
                    printf("{%4s}", "n/a");
            }
            printf("\n");
        }
    }
}

void ReleaseResources(DriversTable** dt)
{
    DriversTable* drv = *dt;
    if( drv == NULL)
    {
      printf("nothing to release!\n");
      return;
    }
    for(int i = 0; i < drv->numdrivers; i++)
    {
        if( drv->drivers[i]  != NULL)
        {
            free(drv->drivers[i]->races);
            drv->drivers[i]->races = NULL;
            free(drv->drivers[i]);
            drv->drivers[i]=NULL;
        }
    }

    free(drv->drivers);
    drv->drivers = NULL;
    free(drv);
    *dt = NULL;
    printf("released!\n");
}

int main()
{
    DriversTable *drv = allocDriversTable(10);
    addDriver(drv,"Emerson", 6);
    setDriverTimeForTheRace(drv,"Emerson",1, 34.5);
    setDriverTimeForTheRace(drv,"Emerson",2, 33.6);
    setDriverTimeForTheRace(drv,"Emerson",7, 34.5);
    addDriver(drv,"Lake",7);
    setDriverTimeForTheRace(drv,"Lake",3, 21.5);
    setDriverTimeForTheRace(drv,"Lake",5, 22.6);
    setDriverTimeForTheRace(drv,"Lake",7, 23.5);
    addDriver(drv,"Palmer",8);
    setDriverTimeForTheRace(drv,"Palmer",4, 21.5);
    setDriverTimeForTheRace(drv,"Palmer",6, 22.6);
    setDriverTimeForTheRace(drv,"Palmer",7, 23.5);
    printDriversTable(drv);
    ReleaseResources(&drv);
    ReleaseResources(&drv);
    return 0;
}

#包括
#包括
#包括
类型定义结构空间{
浮动时间；
}种族；
类型定义结构驱动程序{
char DriverName[50]；
国际诺拉塞斯；
种族*种族；
}司机；
typedef结构sDriversTable{
国际努姆德里弗斯；
司机**司机；
}司机台；
驱动程序*allocDriver（字符*名称，整数）
{
Driver*Driver=calloc（1，sizeof（Driver））；
驱动程序->NoRaces=numraces；
str