# Help Understanding Some Basics

• 10-02-2010
TheProfessor
Help Understanding Some Basics
I just recently bought the book:

Mastering Algorithms with C

In it, the author provides code for some basic data structures. I am in the process of transcribing them to my machine using vim. Along the way I am attempting to write some basic programs using these data structures just to test my knowledge and help my understanding more.

However, I have run into a bit of a problem. I am unable to figure out how to use the very first one. I will provide you with the code if you can please explain to me how exactly I am to use these structures. I am a bit new to C, but I am really trying here. Any help would be much appreciated.

list.h

Code:

```/**  * list.h  **/ #ifndef LIST_H #define LIST_H /**  * Define a structure for linked list elements  **/ typedef struct ListElmt_ {       void *data;     struct ListElmt_ *next; } ListElmt; /**  * Define a structure for linked lists  **/ typedef struct List_ {         int size;         int (*match)(const void *key1, const void *key2);     void (*destroy)(void *data);     ListElmt *head;     ListElmt *tail; } List; /**  * Public Interface  **/ 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); #define list_size(list) ((list)->size) #define list_head(list) ((list)->head) #define list_tail(list) ((list)->tail) #define list_is_head(list, element) ((element) == (list)->head ? 1 : 0) #define list_is_tail(list, elememt) ((element) == (list)->tail ? 1 : 0) #define list_data(element) ((element)->data) #define list_next(element) ((element)->next) #endif```
Code:

```/**  * list.c  **/ #include <stdlib.h> #include <string.h> #include "list.h" /**  * list_init  **/ void list_init(List *list, void (*destroy)(void *data)) {     /**     * initializes the list     **/     list->size = 0;     list->destroy = destroy;     list->head = NULL;     list->tail = NULL;     return; } /**  * list_destroy  **/ void list_destroy(List *list) {     void *data;     /**     * remove each element     **/     while (list_size(list) > 0) {         if (list_rem_next(list, NULL, (void **)&data) == 0 && list->destroy != NULL) {             /**             * Call a user-defined function to free dynamically allocated data.             **/             list->destroy(data);                 }     }     /**     * No operations are allowed now, but clear the structer as a precaution.     **/     memset(list, 0, sizeof(List));     return; } /**  * list_ins_next  **/ int list_ins_next(List *list, ListElmt *element, const void *data) {     ListElmt *new_element;     /**     * Allocate storage for the element.     **/     if ((new_element = (ListElmt *)malloc(sizeOf(ListElmt))) == NULL)         return -1;     /**     * Insert the element into the list.     **/     new_element->data = (void *)data;     if (element == NULL) {         /**         * Handle insertion at the head of the list.         **/         if (list_size(list) == 0)             list->tail = new_element;         new_element->next = list->head;         list->head = new_element;     }     else {         /**         * Handle insertion somewhere other than at the head.         **/         if (element->next == NULL)             list->tail = new_element;         new_element->next = element->next;         element->next = new_element;     }     /**     * Adjust the size of the list to account for the inserted element.     **/     list->size++;     return 0; } /**  * list_rem_next  **/ int list_rem_next(List *list, ListElmt *element, void **data) {     ListElmt *old_element;     /**     * Do not allow removal from an empty list.     **/     if (list_size(list) ==0)         return -1;     /**     * Remove the element from the list.     **/     if (element == NULL) {         /**         * Handle removal from the head of the list.         **/         *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 other than the head.         **/         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 the storage allocated by the abstract datatype.     **/     free(old_element);     /**     * Adjust the size of the list to account for the removed element.     **/     list->size--;     return 0; }```
This is my basic testprog.c
I am mainly just trying to take baby steps so I can get something to atleast compile. However, I am having issues understanding the correct usage of the list_init function.

Code:

```int main() {     List mainList;     void *data;     mainList = list_init(&mainList,free(&data));     return 0; }```
I am having a tough time understanding the function pointer concept i suppose. I understand it is a pointer to a function, but the function must have arguments passed to it. What am I supposed to pass to the free() macro to get this to compile and also properly use it when i call list_destroy.

• 10-02-2010
laserlight
The call should just be:
Code:

`list_init(&mainList, free);`
or equivalently:
Code:

`list_init(&mainList, &free);`
The linked list library code is responsible for passing the argument when calling the free function.

Note that you should #include <stdlib.h> in testprog.c for the free function.
• 10-02-2010
TheProfessor
Thanks!!! I just kinda noticed that the list_init was void and I was trying to use it to assign haha. I appreciate the insight though!!