Queue using an ADT interface

#include <stdio.h>

stdio.h declares printf, puts, getchar and putchar. The input helper reads characters with getchar; the main program prints operation results using the output functions.

#include <stdlib.h>

stdlib.h declares strtol for converting an integer token. It also declares malloc and free, which the linked structures and tree programs use to obtain and release node storage.

#include <string.h>

string.h declares utilities such as memset. It is part of the shared header list; merely including a header does not call any function or change stored values.

#include <ctype.h>
#include <errno.h>

ctype.h supplies isspace for recognising whitespace. errno.h supplies errno so the program can detect a range error reported by strtol.

/* Read a complete integer token; reject bad or oversized input safely. */
int readInt(int *value) {

The comment states the purpose of readInt. Its int *value parameter receives the address of a caller variable. The helper returns 1 after storing a valid value there, or 0 on failure; these flags are separate from main’s process exit status.

    char token[64];
    int ch;
    size_t used = 0;

token holds up to 63 input characters and a null terminator. ch is int so it can distinguish character input from EOF. used starts at zero and counts the stored token characters.

    while ((ch = getchar()) != EOF && isspace((unsigned char)ch)) { }
    if (ch == EOF) return 0;

getchar reads one character at a time. The loop discards whitespace before the token. The unsigned-char cast supplies an allowed argument to isspace. If EOF is reached before a token starts, return 0 without changing the caller variable.

    do {
        if (used < sizeof token - 1) token[used++] = (char)ch;

The do-while body handles the first non-whitespace character already read. The size check leaves one buffer slot for a null terminator. used++ uses the old index for storage, then advances the count.

        else {
            while ((ch = getchar()) != EOF && !isspace((unsigned char)ch)) { }
            return 0;
        }

When the buffer has no character space left, consume the rest of that token through whitespace or EOF, then return failure. The program does not silently treat a truncated prefix as the full input number.

        ch = getchar();
    } while (ch != EOF && !isspace((unsigned char)ch));

Keep collecting until whitespace or EOF. The terminating whitespace has been consumed by getchar; it is not stored as part of the token.

    token[used] = '\0';
    char *end;
    errno = 0;

Write the null terminator after the stored token. end will identify where conversion stopped. Reset errno before strtol so a previous library error cannot be mistaken for this conversion’s result.

    long result = strtol(token, &end, 10);

strtol reads token in base 10 and returns a long. Passing &end lets it write the address of the first unconverted character. A sign such as - is allowed as part of a valid integer token.

    if (errno || *end != '\0' || result < -1000000 || result > 1000000) return 0;

A nonzero errno rejects a reported conversion error. *end must be the null terminator, so input such as 12x is rejected rather than accepted as 12. The allowed value range is -1,000,000 to 1,000,000.

    *value = (int)result;
    return 1;
}

After validation, cast result to int and assign it through *value. Return 1 for success. The brace ends readInt. The caller variable remains unchanged on the earlier failure returns.

/* Queue ADT interface implemented with front/rear linked-list pointers. */
typedef struct Node { int data; struct Node *next; } Node;
typedef struct { Node *front, *rear; } Queue;

The comment describes the representation. A Node stores data and a next link. Queue keeps front, the oldest node, and rear, the newest. This supports enqueue and dequeue without traversing the whole queue.

void initQueue(Queue *q) { q->front = q->rear = NULL; }

initQueue receives the caller’s state by address. In an empty linked queue both front and rear must be null.

int enqueue(Queue *q, int value) {
    Node *node = malloc(sizeof *node);
    if (!node) return 0;
    node->data = value; node->next = NULL;

malloc reserves one Node. On failure return 0 without altering the queue. On success, store value and set next to NULL because the new item will be last.

    if (q->rear) q->rear->next = node;
    else q->front = node;
    q->rear = node; return 1;
}

If rear already exists, connect its next to node. If the queue was empty, front must also become node. In both cases set rear to node and return success. The old front is unchanged for a nonempty queue.

int dequeue(Queue *q, int *value) {
    if (!q->front) return 0;

A null front indicates underflow. Return failure before reading a node or modifying the caller’s output variable.

    Node *node = q->front; *value = node->data;
    q->front = node->next;

Copy the integer into *value while the old node is alive, then advance q->front to node->next. node still identifies the storage that must be released.

    if (!q->front) q->rear = NULL;
    free(node); return 1;
}

If the new front is NULL, the queue became empty, so rear must also become NULL. Otherwise rear would keep a dangling pointer. Free the old front node and return success.

int peek(const Queue *q, int *value) {
    if (!q->front) return 0;
    *value = q->front->data; return 1;
}

Return 0 for an empty queue. Otherwise copy the front integer through the output pointer and return 1. No link changes or free calls occur.

void display(const Queue *q) {
    printf("Queue (front to rear):");
    for (const Node *p = q->front; p; p = p->next) printf(" %d", p->data);
    putchar('\n');
}

Follow next links beginning at front and print each integer. Stop at NULL, then end the line. The const access and separate traversal pointer leave the queue state unchanged.

void destroyQueue(Queue *q) { int ignored; while (dequeue(q, &ignored)) { } }

Repeated dequeue calls free each front node. ignored receives the integers that are no longer needed. The final successful removal resets both endpoints.

/* 1 value: enqueue; 2: dequeue; 3: peek; 4: display; 0: exit. */
int main(void) {

Commands request enqueue, dequeue, peek, display or normal exit. The following driver uses these operations rather than directly editing links.

    Queue q; initQueue(&q);
    int command, value;

initQueue makes q explicitly empty before any operation. command and value hold checked input and successful output values.

    while (readInt(&command)) {
        if (command == 0) { destroyQueue(&q); return 0; }

Command 0 destroys all remaining nodes and returns success. If command reading fails instead, execution reaches the error cleanup after the loop.

        if (command == 1) {
            if (!readInt(&value)) break;
            puts(enqueue(&q, value) ? "Enqueued." : "Allocation failed; queue unchanged.");

Command 1 needs one following value. A failed read breaks to cleanup. Otherwise enqueue reports success or allocation failure without exposing internal node addresses.

        } else if (command == 2) {
            if (dequeue(&q, &value)) printf("Dequeued: %d\n", value);
            else puts("Underflow: queue is empty.");

The caller passes &value. Print it only when dequeue succeeds; underflow leaves no returned queue item to display.

        } else if (command == 3) {
            if (peek(&q, &value)) printf("Front: %d\n", value);
            else puts("Queue is empty.");

Command 3 prints the front value on success or an empty-queue message on failure. The next dequeue will still return that same front item.

        } else if (command == 4) display(&q);
        else break;
    }

Command 4 traverses the queue. Any remaining command breaks to the shared error path. The brace closes the reading loop.

    puts("Invalid or incomplete input. End with command 0.");
    destroyQueue(&q); return 1;
}

Print the error message, call destroyQueue to free owned nodes, and return failure. This complements the normal command-0 cleanup.