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
    23,621
    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.
    Quote Originally Posted by Bjarne Stroustrup (2000-10-14)
    I get maybe two dozen requests for help with some sort of programming or design problem every day. Most have more sense than to send me hundreds of lines of code. If they do, I ask them to find the smallest example that exhibits the problem and send me that. Mostly, they then find the error themselves. "Finding the smallest program that demonstrates the error" is a powerful debugging tool.
    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, 01:29 AM
  2. Understanding Headers
    By AeonMoth in forum C++ Programming
    Replies: 2
    Last Post: 06-27-2007, 05:53 AM
  3. trouble understanding the source file structure
    By Mario F. in forum C++ Programming
    Replies: 5
    Last Post: 05-26-2006, 06:46 PM
  4. understanding recursive functions
    By houler in forum C Programming
    Replies: 7
    Last Post: 12-09-2004, 11:56 AM
  5. The Basics
    By Granger9 in forum Windows Programming
    Replies: 5
    Last Post: 09-13-2002, 05:12 PM

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