# Thread: Help Understanding Some Basics

1. ## Help Understanding Some Basics

I just recently bought the book:

Mastering Algorithms with C

A Link to the book

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 *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_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->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;

}

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.
**/

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.

2. 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.

3. 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!!

Popular pages Recent additions