Stack 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

The macro gives the array five element slots, with valid indexes 0 through 4. It is a source-level constant, not a counter that changes during operations.

int push(int stack[], int *top, int value) {
    if (*top == CAPACITY - 1) return 0;

stack[] gives access to the caller’s array and top points to its current top index. If *top already equals CAPACITY - 1, all slots are occupied. Return 0 before incrementing top or storing a new value.

    stack[++(*top)] = value;
    return 1;
}

++(*top) increments the caller’s index before the array access. Starting from -1, the first push writes stack[0]. Return 1 after storage succeeds. The brace closes push.

int pop(int stack[], int *top, int *value) {
    if (*top == -1) return 0;

value points to the caller’s output variable. top equal to -1 means no element exists, so return 0 without reading the array or assigning an output value.

    *value = stack[(*top)--];
    return 1;
}

The post-decrement uses the current index for the read, then reduces top by one. Copy the integer through *value and return success. The old array bytes need not be erased: top determines which elements belong to the stack.

void display(const int stack[], int top) {
    printf("Stack (top to bottom):");
    for (int i = top; i >= 0; --i) printf(" %d", stack[i]);
    putchar('\n');
}

The display function receives top by value. Its local loop starts at that index and walks down to zero, so the most recently pushed value prints first. Empty stacks print only the heading and newline.

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

The comment describes push, pop, peek, display and exit requests. main is the command-reading entry function.

    int stack[CAPACITY], top = -1, command, value;

The storage has CAPACITY slots. top = -1 represents emptiness. command and value hold operation inputs and successful pop results.

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

Continue while readInt accepts a command. A zero command returns success from main. No heap nodes need cleanup in this array representation.

        if (command == 1) {
            if (!readInt(&value)) break;
            puts(push(stack, &top, value) ? "Pushed." : "Overflow: stack is full.");

Command 1 needs one following integer value. A missing value breaks to the error path. Otherwise push receives &top so it can update the caller’s index; the conditional expression chooses success or overflow text.

        } else if (command == 2) {
            if (pop(stack, &top, &value)) printf("Popped: %d\n", value);
            else puts("Underflow: stack is empty.");

Command 2 passes &value to pop. Print value only after a successful return, otherwise report underflow. This avoids reading an unassigned output after a failed pop.

        } else if (command == 3) {
            if (top >= 0) printf("Top: %d\n", stack[top]);
            else puts("Stack is empty.");

Command 3 checks top >= 0, then prints stack[top]. It neither decrements top nor removes the item. If the stack is empty, print a message instead of accessing index -1.

        } else if (command == 4) display(stack, top);
        else break;
    }

Command 4 calls display. Any other command breaks out of the loop. The brace closes the command-reading body.

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

If the loop ends without command 0, print the invalid/incomplete-input message and return failure. Array storage is released automatically when main ends.