Help Understanding Some Basics

This is a discussion on Help Understanding Some Basics within the C Programming forums, part of the General Programming Boards category; I just recently bought the book: Mastering Algorithms with C A Link to the book In it, the author provides ...

  1. #1
    Registered User
    Join Date
    Oct 2010
    Posts
    2

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

  2. #2
    C++ Witch laserlight's Avatar
    Join Date
    Oct 2003
    Location
    Singapore
    Posts
    22,304
    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.
    C + C++ Compiler: MinGW port of GCC
    Version Control System: Bazaar

    Look up a C++ Reference and learn How To Ask Questions The Smart Way

  3. #3
    Registered User
    Join Date
    Oct 2010
    Posts
    2
    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 subscribe to a feed

Similar Threads

  1. Understanding forward declarations of classes, pimpl
    By Boxknife in forum C++ Programming
    Replies: 2
    Last Post: 04-22-2010, 02:29 AM
  2. Understanding Headers
    By AeonMoth in forum C++ Programming
    Replies: 2
    Last Post: 06-27-2007, 06:53 AM
  3. trouble understanding the source file structure
    By Mario F. in forum C++ Programming
    Replies: 5
    Last Post: 05-26-2006, 07:46 PM
  4. understanding recursive functions
    By houler in forum C Programming
    Replies: 7
    Last Post: 12-09-2004, 12:56 PM
  5. The Basics
    By Granger9 in forum Windows Programming
    Replies: 5
    Last Post: 09-13-2002, 06:12 PM

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21