1

This is my first question here. I'm unable to understand a couple line of codes in this program.

The custom destroy function pointer is what I'm unable to understand.

I've commented with "need help #1 and need help #2" where I need help with the codes.

Any help would be greatly appreciated and I will be really grateful to anyone who could help me understand these codes.

#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

and here is list.c

#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;
}
4

2 に答える 2

3

質問＃1について

destroy作成時にリンク リストに渡される引数は、関数へのポインタです。リンクされたオブジェクトは、保持しているオブジェクトを破棄してメモリを解放する方法を知りません。したがって、そのアクションを実行するには、外部から何かが必要です。したがって、ユーザーは、リストに保存したオブジェクトのメモリを解放する方法を知っている関数を作成し、ノードを破棄する必要があるときにその関数を使用するようにリンク リストに指示する必要があります。

関数へのポインターはリスト変数に保存されますdestroy。

質問 2 の場合

ポインタを渡した関数が呼び出され、占有しているメモリを解放するために、現在のノードに格納されているデータへのポインタが渡されています。

この手法は、コマンドまたはアクション パターンと呼ばれます(これは oop! に限定されません)。

于 2013-09-29T13:46:09.173 に答える