Queue using an array

#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.

#define CAPACITY 5

This example reserves five array slots. A count distinguishes a full queue from an empty queue, so all five slots can hold items.

int enqueue(int queue[], int *front, int *count, int value) {
    if (*count == CAPACITY) return 0;

front and count point to the caller’s state. If count equals CAPACITY, return 0 before changing any data. This prevents overwriting an item that is still waiting to be removed.

    int rear = (*front + *count) % CAPACITY;

The logical rear position is front plus count, reduced modulo CAPACITY. For front = 4 and count = 2, (4 + 2) % 5 gives index 1.

    queue[rear] = value;
    ++(*count);
    return 1;
}

Write into the calculated rear slot, then increment the caller’s count and return 1. front stays unchanged because enqueue adds after existing items.

int dequeue(int queue[], int *front, int *count, int *value) {
    if (*count == 0) return 0;

A zero count means no front item can be returned. Leave the output variable and queue state unchanged when returning failure.

    *value = queue[*front];
    *front = (*front + 1) % CAPACITY;
    --(*count);
    return 1;
}

Copy queue[*front] into the caller’s output, advance front modulo the capacity, then reduce count. Return success after these fixed changes. No elements are shifted through the array.

void display(const int queue[], int front, int count) {
    printf("Queue (front to rear):");
    for (int i = 0; i < count; ++i) printf(" %d", queue[(front + i) % CAPACITY]);
    putchar('\n');
}

For each used logical position i, calculate (front + i) % CAPACITY. This starts at the oldest item and wraps as needed. Printing physical indexes 0 through count - 1 would be wrong after wraparound.

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

The commands request enqueue, dequeue, front inspection, display or exit. The integer return from main is an execution status.

    int queue[CAPACITY], front = 0, count = 0, command, value;

front starts at index 0 and count starts at 0. The array’s unused bytes do not need initial values because operations read only counted items.

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

The loop accepts checked command tokens. A zero command ends the array-based program without any node cleanup.

        if (command == 1) {
            if (!readInt(&value)) break;
            puts(enqueue(queue, &front, &count, value) ? "Enqueued." : "Overflow: queue is full.");

Command 1 requires the next value. The call supplies addresses of front and count so the helper can update queue state. A full queue reports overflow rather than overwriting an old item.

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

Command 2 passes &value to dequeue. If count was zero, print underflow and do not read an output value that was not assigned by the helper.

        } else if (command == 3) {
            if (count) printf("Front: %d\n", queue[front]);
            else puts("Queue is empty.");

Command 3 reads queue[front] only when count is nonzero. Peek leaves both front and count unchanged.

        } else if (command == 4) display(queue, front, count);
        else break;
    }

Command 4 uses the logical-order display function. Any other command breaks out to the error report. The brace closes the loop body.

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

If normal exit command 0 was not read, print the incomplete-input message and return failure. No heap storage is owned by this array queue.