C 结构实现建议

我有一些非常基本的想法，什么是结构以及它是如何工作的

我的目标是使用以下结构创建考勤计划：

• 输入：工人，他来上班的时间，他离开的时间-他可以离开和来多次（例如午休时间）

• 输出：每个最长的工人工作了多少小时，他是谁

例如：

+ 8:00:00 100

+ 8:50:00 105

- 9:30:00 100

- 18:20:00 105

- 19:00:00 100

- 17:00:00 100

+ 18:00:00 100

+ 9:00:00 200

+ 10:00:00 100

- 15:00:00 200

int *a;
a = (int*) malloc(100*sizeof(int));

输出：

Longest work time: 9:30:00 

Longest workers: 100, 105    

我最初的想法是这样使用struct：

typedef struct work {
    int *arrivals;
    int *departures;
    int *result;
} WORK;
WORK 66, 100, 105, 200;    

然后，我会为到达和离开动态分配内存，对它们进行排序，并比较

到达[I]

和

离开[I]

的元素

这样做的问题是，元素（工作者）的数量可能会有所不同，您无法将新元素动态添加到结构中

---

那么，我如何才能改变结构以满足我的需要呢？

如果事先不知道工人的数量，但一旦知道就会固定下来，那么动态分配一组

工作

s。这将以与您执行

到达

s完全相同的方式完成，只是您将使用

工作

struct而不是

时间

struct

---

如果数字会随时间变化，您可以使用

realloc

执行上述操作，但在需要时更改其大小，或者使用更具动态性的结构（如链表）

realloc

类似于

malloc

，不同之处在于它接受一个指针&一个新的大小，并修改它指向的对象（可能移动它）使其成为新的大小。对于链表，您需要（至少）在

结构中添加一个字段，该字段是指向同一类型
结构的指针，用于告诉您列表中下一项的位置。
如果事先不知道工作人员的数量，但一旦知道将是固定的，则动态分配
工作的数组。这将以与您执行
到达
s完全相同的方式完成，只是您将使用
工作
struct而不是
时间
struct

如果数字会随时间变化，您可以使用
realloc
执行上述操作，但在需要时更改其大小，或者使用更具动态性的结构（如链表）
realloc
类似于
malloc
，不同之处在于它接受一个指针&一个新的大小，并修改它指向的对象（可能移动它）使其成为新的大小。对于链表，您需要（至少）在
结构中添加一个字段，该字段是指向同一类型
结构的指针，用于告诉您列表中下一项的位置。
如果事先不知道工作人员的数量，但一旦知道将是固定的，则动态分配
工作的数组。这将以与您执行
到达
s完全相同的方式完成，只是您将使用
工作
struct而不是
时间
struct

如果数字会随时间变化，您可以使用
realloc
执行上述操作，但在需要时更改其大小，或者使用更具动态性的结构（如链表）
realloc
类似于
malloc
，不同之处在于它接受一个指针&一个新的大小，并修改它指向的对象（可能移动它）使其成为新的大小。对于链表，您需要（至少）在
结构中添加一个字段，该字段是指向同一类型
结构的指针，用于告诉您列表中下一项的位置。
如果事先不知道工作人员的数量，但一旦知道将是固定的，则动态分配
工作的数组。这将以与您执行
到达
s完全相同的方式完成，只是您将使用
工作
struct而不是
时间
struct

如果数字会随时间变化，您可以使用
realloc
执行上述操作，但在需要时更改其大小，或者使用更具动态性的结构（如链表）
realloc
类似于
malloc
，不同之处在于它接受一个指针&一个新的大小，并修改它指向的对象（可能移动它）使其成为新的大小。对于链表，您需要（至少）在
结构中添加一个字段，该字段是指向同一类型
结构的指针，用于告诉您列表中的下一项在哪里。
我编写了一段代码，向您展示这是如何工作的。想法是为
工人
和
到达者
/
离开者
提供动态数组

如果您知道如何为某个数组
a
动态分配内存，例如：

+ 8:00:00 100

+ 8:50:00 105

- 9:30:00 100

- 18:20:00 105

- 19:00:00 100

- 17:00:00 100

+ 18:00:00 100

+ 9:00:00 200

+ 10:00:00 100

- 15:00:00 200

int *a;
a = (int*) malloc(100*sizeof(int));

然后您就知道如何使用
struct
s执行此操作：

struct s_name *my_s; // s_name is some random name of structure
my_s = (s_name*) malloc(100*sizeof(s_name));

因此，您知道如何为结构中的某个数组分配内存

代码如下：

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

typedef struct {
  int h, m, s; // hour, minutes, seconds
} time;

typedef struct {
  time *arrival;
  time *departure;
  time result;

  int n_of_arrivals; // to keep track how many we have
  int n_of_departures;

} work;

work *workers;

int main(void) {
  int N;

  printf("How many entries do you have?\n> ");
  scanf("%d", &N);

  // initially create space for 100 workers
  workers = (work*) malloc(100*sizeof(work));
  int number_of_workers = 100;

  for (int n = 0; n < N; n++) {
    char event; // this is '+' or '-'
    int h, m, s, id;

    scanf(" %c %d:%d:%d%d", &event, &h, &m, &s, &id);

    // last position where we can put our worker is number_of_workers - 1
    if (id > number_of_workers - 1) {
      number_of_workers = id + 1;
      // realloc memory for storing workers
      workers = (work*) realloc(workers, number_of_workers*sizeof(work));
    }

    if (event == '+') {
      // add 1 to amount of arrivals
      workers[id].n_of_arrivals += 1;

      int len = workers[id].n_of_arrivals;

      // realloc memory for keeping arrivals of worker
      workers[id].arrival = (time*) realloc(workers[id].arrival, len*sizeof(time));

      // finally store new time
      time *arrival = workers[id].arrival;
      arrival[len - 1].h = h;
      arrival[len - 1].m = m;
      arrival[len - 1].s = s;
    } else {
      // this is the same as for adding arrivals
      workers[id].n_of_departures += 1;
      int len = workers[id].n_of_departures;
      workers[id].departure = (time*) realloc(workers[id].departure, len*sizeof(time));
      time *departure = workers[id].departure;
      departure[len - 1].h = h;
      departure[len - 1].m = m;
      departure[len - 1].s = s;
    }
  }

  for (int i = 0; i < number_of_workers; i++) {
    // skip worker who doesn't have track of any arrivalls or depratures
    if (!workers[i].n_of_arrivals && !workers[i].n_of_departures)
      continue;

    printf("Worker %d:\n", i);

    // print nicely arrivals
    if (workers[i].n_of_arrivals) {
      int len = workers[i].n_of_arrivals;
      printf("Arrivals:\n");
      for (int k = 0; k < len; k++)
        printf("%d:%d:%d\n", workers[i].arrival[k].h, workers[i].arrival[k].m, workers[i].arrival[k].s);
    }

    // // print nicely depratures
    if(workers[i].n_of_departures) {
      int len = workers[i].n_of_departures;
      printf("Departures:\n");
      for (int k = 0; k < len; k++)
        printf("%d:%d:%d\n", workers[i].departure[k].h, workers[i].departure[k].m, workers[i].departure[k].s);
    }

    printf("\n");
  }

  return 0;
}

#包括
#包括
类型定义结构{
int h，m，s；//小时，分钟，秒
}时间；
类型定义结构{
时间*到达；
时间*出发；
时间结果；
int n_of_arrivals；//记录我们有多少人
离港国际航班；
}工作；
工作*工人；
内部主（空）{
int N；
printf（“您有多少个条目？\n>”；
scanf（“%d”和“&N”）；
//最初为100名工人创造空间
工人=（工作*）malloc（100*sizeof（工作））；
工人的整数=100；
对于（int n=0；n工人数量-1）{
工人数量=id+1；
//用于存储工人的realloc内存
工人=（工作*）realloc（工人、工人数量*工作规模）；
}
如果（事件=='+'）{
//将1添加到到达量
工人[id]。到达人数的n个+=1；
int len=workers[id].n个到达者；
//realloc内存用于保存工作进程的到达
工人[id]。到达=（时间*）reallo