如何将proc结构体数据传入队列函数存入void* info指针？

我需要从标准输入读取数据存入自定义的proc结构体，再将该结构体的信息存入优先级队列的Queue_element中的void* info指针。现有相关结构体及nolock_add_to_queue函数定义如下，且不能修改该添加函数，求实现方法。

proc结构体定义 #

typedef struct proc{
int creationTime;
int pid; 
int runTime;
int ioTime; 
int repeat;
}proc;

优先级队列结构体定义 #

// type of one element in a queue 
typedef struct _Queue_element {
  void *info; //<- THIS IS WHERE ALL INFO FROM THE PROCESS STRUCTURE WILL BE STORED WHEN ADDED TO THE QUEUE
  int priority;
  struct _Queue_element *next;
} *Queue_element;

//basic queue type
typedef struct Queue {
  Queue_element queue;                           
  Queue_element tail;                            
  Queue_element current;                         
  Queue_element previous;                         
  unsigned long queuelength;                         
  unsigned int elementsize;                       
  unsigned int duplicates;                      
  int (*compare) (const void *e1, const void *e2); 
  pthread_mutex_t lock;
  int priority_is_tag_only;    
} Queue;

nolock_add_to_queue函数定义 #

static void nolock_add_to_queue(Queue *q, void *element, int priority) {

  Queue_element new_element, ptr, prev = NULL;

  if (! q->duplicates && ! q->compare) {
    fprintf(stderr, "If duplicates are disallowed, the comparison function must be specified in init_queue().\n");
    exit(1);
  }
  
  if (!q->queue ||
     (q->queue && (q->duplicates || !nolock_element_in_queue(q, element)))) {

    new_element = (Queue_element) malloc(sizeof(struct _Queue_element));
    if (new_element == NULL) {
      fprintf(stderr, "malloc() failed in function add_to_queue()\n");
      exit(1);
    }
    new_element->info = (void *)malloc(q->elementsize);
    if (new_element->info == NULL) {
      fprintf(stderr, "malloc() failed in function add_to_queue()\n");
      exit(1);
    }

    memcpy(new_element->info, element, q->elementsize);

    new_element->priority = priority;

    (q->queuelength)++;

    if (q->queue == NULL) {             // first element
      new_element->next = NULL;
      q->queue = new_element;
      q->tail = new_element;
    }
    else if (q->priority_is_tag_only) { // FIFO queue
      q->tail->next = new_element;
      q->tail = new_element;
      new_element->next = NULL;
    }
    else {                              // priority queue
      ptr=q->queue;
      while (ptr != NULL && priority <= ptr->priority) {
    prev = ptr;
    ptr = ptr->next;
      }

      if (! prev) {   // queue only had one element and new element
              // has higher priority
    new_element->next=q->queue;
    q->tail = q->queue;
    q->queue=new_element;
      }
      else {         // insert new element 
    new_element->next = prev->next;
    prev->next = new_element;
    if (new_element->next == NULL) {
      // new tail
      q->tail = new_element;
    }
      }
    }
    
    nolock_rewind_queue(q);
    
  }
}

实现步骤 #

1. 初始化优先级队列 #

首先要确保队列的elementsize字段被正确设置为sizeof(proc)，函数内部会根据这个值分配内存并拷贝数据。另外根据需求设置duplicates（是否允许重复元素）和compare函数（禁止重复时必须提供），示例初始化代码：

Queue my_queue;
// 初始化队列成员
memset(&my_queue, 0, sizeof(Queue));
my_queue.elementsize = sizeof(proc);
my_queue.duplicates = 1; // 允许重复元素，无需compare函数
// 如果禁止重复，需定义compare函数并赋值：
// int compare_proc(const void *e1, const void *e2) {
//     proc *p1 = (proc*)e1;
//     proc *p2 = (proc*)e2;
//     // 示例按pid比较，返回0表示相同
//     return p1->pid - p2->pid;
// }
// my_queue.duplicates = 0;
// my_queue.compare = compare_proc;
// 初始化互斥锁（后续需线程安全操作时使用）
pthread_mutex_init(&my_queue.lock, NULL);

2. 读取输入到proc结构体 #

从标准输入读取数据填充proc实例：

proc new_proc;
// 示例：从stdin读取五个整数对应proc的字段
scanf("%d %d %d %d %d", &new_proc.creationTime, &new_proc.pid, &new_proc.runTime, &new_proc.ioTime, &new_proc.repeat);

3. 调用nolock_add_to_queue存入队列 #

直接将new_proc的地址作为element参数传入，同时指定该元素的优先级：

// 示例：以creationTime作为优先级，可自定义规则
int priority = new_proc.creationTime;
nolock_add_to_queue(&my_queue, &new_proc, priority);

函数内部会自动根据my_queue.elementsize分配内存，并通过memcpy将new_proc的所有数据拷贝到new_element->info指向的内存区域，完成结构体的存储。

4. 从队列取出并访问proc数据（可选） #

从队列中取出元素时，需将void* info强制转换为proc*类型来访问字段：

// 示例：获取队列首元素
Queue_element elem = my_queue.queue;
proc *p = (proc*)elem->info;
// 访问结构体字段
printf("PID: %d, Creation Time: %d\n", p->pid, p->creationTime);
// 释放内存：先释放info指向的内存，再释放Queue_element本身
free(p);
free(elem);

内容的提问来源于stack exchange，提问作者JSONdaMAN