Thread: ADT queue

I want a queue that can handle any data type I throw at it, so I decided to use pointers for the data element inside the linked list. Anyone have a better way of doing it, or any comments on the code?

queue.h

Code:

#ifndef QUEUE_H
#define QUEUE_H

typedef void *qelem_t;

typedef struct qnode
{
        qelem_t elem;
        struct qnode *next;
        struct qnode *prev;
}qnode;

typedef struct
{
        qnode *back;
        qnode *front;
}queue;

/*
 * Create an queue.
 */
queue *q_create(void);

/*
 * Destroy an queue.
 * Returns 1 on success, and otherwise 0.
 */
int q_destroy(queue *q);

/*
 * Check if queue is empty.
 * Returns 1 if the queue is empty, and otherwise 0.
 */
int q_isempty(queue *q);

/*
 * Add element to queue.
 * Returns 1 on success, and otherwise 0.
 */
int q_enqueue(queue *q, qelem_t elem);

/*
 * Remove element from queue, and return it.
 */
qelem_t q_dequeue(queue *q);

#endif

queue.c

Code:

#include <stdlib.h>
#include "queue.h"

queue *q_create(void)
{
        queue *q = malloc(sizeof(*q));
        if (!q)
                return NULL;
        q->back = NULL;
        q->front = NULL;
        return q;
}

int q_destroy(queue *q)
{
        if (!q)
                return 0;
        while (!q_isempty(q))
                q_dequeue(q);
        free(q);
        return 1;
}

int q_isempty(queue *q)
{
        if (!q)
                return 1;
        if (!q->front)
                return 1;
        else
                return 0;
}

int q_enqueue(queue *q, qelem_t elem)
{
        qnode *new = malloc(sizeof(*new));
        if (!new)
                return 0;
        if (!q || !elem)
        {
                free(new);
                return 0;
        }
        new->elem = elem;
        new->next = q->back;
        new->prev = NULL;
        if (q->back)
                q->back->prev = new;
        q->back = new;
        if (!q->front)
                q->front = new;
        return 1;
}

qelem_t q_dequeue(queue *q)
{
        qnode *prev;
        qelem_t *elem;
        if (q_isempty(q))
                return NULL;
        prev = q->front->prev;
        elem = q->front->elem;
        free(q->front);
        q->front = prev;
        return elem;
}

main.c

Code:

#include <stdio.h>
#include <stdlib.h>
#include "queue.h"

int main(void)
{
        unsigned int i;
        qelem_t elem; /* Pointer to an ADT */
        queue *q = q_create();
        const int numbers[] = {0,1,2,3,4,5,6,7,8,9};
        const char *msg[] = {
                "abc",
                "123",
                NULL
        };

        for (i=0; i<2; i++)
        {
                if (!q_enqueue(q, (qelem_t) msg[i]))
                        puts("Enqueue error");
        }

        for (; i>0; i--)
        {
                elem = q_dequeue(q);
                if (!elem)
                        puts("Dequeue error");
                printf("%s\n", (char *) elem);
        }

        if (!q_destroy(q))
        {
                puts("Invalid queue pointer");
                return EXIT_FAILURE;
        }
        q = q_create();

        for (i=0; i<10; i++)
        {
                if (!q_enqueue(q, (qelem_t) &numbers[i]))
                        puts("Enqueue error");
        }

        for (; i>0; i--)
        {
                elem = q_dequeue(q);
                printf("%d\n", *(int *) elem);
        }
        if (!q_destroy(q))
        {
                puts("Invalid queue pointer");
                return EXIT_FAILURE;
        }
        return 0;
}

This is just some lint.

Code:

int q_destroy(queue *q)
{
        if (!q)
                return 0;
        while (!q_isempty(q))
                q_dequeue(q);
/* [Warning 534] Ignoring return value of function 'q_dequeue(struct {...} *)' */
        free(q);
        return 1;
}

Code:

int q_isempty(queue *q)
{
        if (!q)
                return 1;
        if (!q->front)
                return 1;
        else
                return 0;
}/* [Info 818] Pointer parameter 'q' could be declared as pointing to const */

Code:

int q_enqueue(queue *q, qelem_t *elem)
{
        qnode *new = malloc(sizeof(*new));
        if (!new)
                return 0;
        if (!q || !elem)
                return 0; /* [Warning 429] Custodial pointer 'new' has not been freed or returned */
        new->elem = elem;
        new->next = q->back;
        new->prev = NULL;
        if (q->back)
                q->back->prev = new;
        q->back = new;
        if (!q->front)
                q->front = new;
        return 1;
}

Code:

int main(void)
{
        unsigned int i;
        qelem_t elem; /* Pointer to an ADT */
        queue *q = q_create();
        const int numbers[] = {0,1,2,3,4,5,6,7,8,9};
        const char *msg[] = {
                "abc",
                "123",
                NULL
        };

        for (i=0; i<2; i++)
        {
                if (!q_enqueue(q, (qelem_t *) msg[i]))
/* [Info 826] Suspicious pointer-to-pointer conversion (area too small) */
                {
                                puts("Enqueue error");
                                return EXIT_FAILURE;
                }
        }

        for (; i>0; i--)
        {
                elem = q_dequeue(q);
                if (!elem)
                {
                        puts("Dequeue error");
                        return EXIT_FAILURE;
                }
                printf("%s\n", (char *) elem);
        }

        q_destroy(q); /* Could probably use a q_clear(q) func here instead */
/* [Warning 534] Ignoring return value of function 'q_destroy(struct {...} *)' */
        q = q_create();

        for (i=0; i<10; i++)
                q_enqueue(q, (qelem_t *) &numbers[i]);
/* [Warning 534] Ignoring return value of function 'q_enqueue(struct {...} *, void **)' */
        for (; i>0; i--)
        {
                elem = q_dequeue(q);
                printf("%d\n", *(int *) elem);
/* [Warning 613] Possible use of null pointer 'unknown-name' in argument to operator 'unary *' */
        }

        return 0;
}