C语言 用户定义的销毁(免费)函数

Question

这是我的第一个问题。我无法理解该程序中的几行代码。

自定义销毁函数指针是我无法理解的。

我已经评论了"需要帮助#1和需要帮助#2"，我需要代码方面的帮助。

任何

帮助将不胜感激，我将非常感谢任何可以帮助我理解这些代码的人。

#ifndef LIST_H
#define LIST_H
#include <stdio.h>
typedef struct _ListElmt
{
  void *data;
  struct ListElmt *next;
} ListElmt;
typedef struct _List
{
  int size;
  int (*match)(const void *key1, const void *key2);
  void (*destroy)(void *data);
  ListElmt *head;
  ListElmt *tail;
} List;
void list_init(List *list, void (*destroy)(void *data));
void list_destroy(List *list);
int list_ins_next(List *list, ListElmt *element, const void *data);
int list_rem_next(List *list, ListElmt *element, void **data);
int list_size(const List *list);
ListElmt *list_head(const List *list);
ListElmt *list_tail(const List *list);
int list_is_head(const ListElmt *element);
int list_is_tail(const ListElmt *element);
void *list_data(const ListElmt *element);
ListElmt *list_next(const ListElmt *element);
#endif

这是列表。

#include <stdlib.h>
#include <string.h>
#include "List.h"
/* Need Help #1: The destroy function pointer is called here when the list is initialized and I need some explanation on how this works */
void list_init(List *list, void (*destroy)(void *data))
{
  list->size = 0;
  list->destroy = destroy;
  list->head = NULL;
  list->tail = NULL;
  return;
}
void list_destroy(List *list)
{
  void *data;
  while (list_size(list) > 0)
  {
    if (list_rem_next(list, NULL, (void **) &data) == 0&& list->destroy != NULL)
    {
      list->destroy(data);
      /* Need Help #2: The above line - how this works. I have no idea how this works because I haven't seen any code like that before. Also kindly let me know if this is recursion or not.*/
    }
  }
  memset(list, 0, sizeof(List));
  return;
}
int list_ins_next(List *list, ListElmt *element, const void *data)
{
  ListElmt *new_element;
  if ((new_element = (ListElmt *) malloc(sizeof(ListElmt))) == NULL ) // not yet understanded
    return -1;
  new_element->data = (void *) data;
  if (element == NULL )
  {
    if (list_size(list) == 0)
      list->tail = new_element;
    new_element->next = list->head;
    list->head = new_element;
  }
  else
  {
    if (element->next == NULL )
      list->tail = new_element;
    new_element->next = element->next;
    element->next = new_element;
  }
  list->size++;
  return 0;
}
int list_rem_next(List *list, ListElmt *element, void **data)
{
  ListElmt *old_element;
  if (list_size(list) == 0)
    return -1;
  if (element == NULL )
  { // Handle removal of the head
    *data = list->head->data;
    old_element = list->head;
    list->head = list->head->next;
    if (list_size(list) == 1)
      list->tail = NULL;
  }
  else
  { // Handle removal from somewhere else
    if (element->next == NULL )
      return -1;
    *data = element->next->data;
    old_element = element->next;
    element->next = element->next->next;
    if (element->next == NULL )
      list->tail = element;
  }
  free(old_element);
  list->size--;
  return 0;
}

Answer 1

对于问题 #1

创建时传递给链表destroy参数是指向函数的指针。链接不知道如何销毁它持有的对象，从而释放内存。所以它需要来自外部的东西来为它执行该操作。因此，作为用户，您必须编写一个函数，该函数知道如何释放您保存在列表中的对象的内存，并告诉链表在需要销毁节点时使用该函数。

指向函数的指针保存在列表变量 destroy 中。

对于问题 #2

刚刚调用了已向其传递指针的

函数，并且正在向其传递指向存储在当前节点中的数据的指针，以释放它占用的内存。

这种技术被称为命令或操作模式（它不仅限于 oop！

Answer 2

• #help1 ：= 不调用任何内容;函数指针只赋给： 赋值后 list->destroy 包含销毁函数的地址。
• #help2 ：= 现在调用函数：func(arg)是函数调用，如果fncptr是指向函数类型的指针，则funcptr(arg)
也是如此
• #help3 ：= memset(list, 0, sizeof(List));错误地假定NULL指针值由全零表示。它不一定是。（在大多数情况下是这样，但一个结构可能有不同的表示NULL）