Thread: 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 *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.

Thanks in advance!!!

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