C++ 通过数组实现的栈

#ifndef __ARRAY_STACK_C2025__
#define __ARRAY_STACK_C2025__

#define ARRAY_STACK_MAX 1024

typedef int array_stack_data;

typedef struct
{
    array_stack_data array[ARRAY_STACK_MAX];
    int top;
} array_stack, *array_stack_ptr;

bool is_empty_array_stack(array_stack_ptr stack);

void init_array_stack(array_stack_ptr stack);

bool is_full_array_stack(array_stack_ptr stack);

void push_array_stack(array_stack_ptr stack, array_stack_data data);

array_stack_data pop_array_stack(array_stack_ptr stack);

void out_array_stack(array_stack_ptr stack);

void clear_array_stack(array_stack_ptr stack);

array_stack_ptr create_array_stack();

void free_array_stack(array_stack_ptr stack);

#define destroy_array_stack(stack)   \
    do                               \
    {                                \
        if (stack)                   \
        {                            \
            free_array_stack(stack); \
            stack = null;            \
        }                            \
    } while (0)

#endif

#include "../util.h"
#include "array_stack.h"

bool is_empty_array_stack(array_stack_ptr stack)
{
    return !stack || stack->top == -1;
}

bool is_full_array_stack(array_stack_ptr stack)
{
    return stack && stack->top /*index from 0 to MAX-1*/ >= ARRAY_STACK_MAX;
}

void init_array_stack(array_stack_ptr stack)
{
    if (stack)
    {
        stack->top = -1;
    }
}

void push_array_stack(array_stack_ptr stack, array_stack_data data)
{
    if (stack && stack->top < ARRAY_STACK_MAX)
    {
        stack->array[++stack->top] = data;
    }
}

array_stack_data pop_array_stack(array_stack_ptr stack)
{

    if (stack && stack->top >= 0)
    {
        return stack->array[stack->top--];
    }
    return 0;
}

void out_array_stack(array_stack_ptr stack)
{
    if (!is_empty_array_stack(stack))
    {
        for (int i = 0; i < stack->top; i++)
        {
            printf("%d ", stack->array[i]);
        }
        printf("%d\n", stack->array[stack->top]);
    }
}

void clear_array_stack(array_stack_ptr stack)
{
    if (stack)
    {
        stack->top = -1;
    }
}

array_stack_ptr create_array_stack()
{
    array_stack_ptr p = malloc(sizeof(array_stack));

    init_array_stack(p);

    return p;
}

void free_array_stack(array_stack_ptr stack)
{
    if (stack)
    {
        free(stack);
        stack = null;
    }
}

#include "../util.h"
#include "array_stack.h"

int main()
{

    array_stack stack;

    p_i(stack.top);

    init_array_stack(&stack);

    p_i(stack.top);

    out_array_stack(&stack);

    // srand(time(0));
    for (int i = 0; i < 20; i++)
    {
        // push_array_stack(&stack, rand() % 100);
        push_array_stack(&stack, next_rand_limit_max(100));
    }

    out_array_stack(&stack);

    for (int i = 0; i < 19; i++)
    {
        array_stack_data data = pop_array_stack(&stack);
        printf("%d ", data);
    }
    printf("%d\n", pop_array_stack(&stack));
    printf("%d\n", pop_array_stack(&stack));

    for (int i = 0; i < 30; i++)
    {
        push_array_stack(&stack, rand() % 100);
    }

    out_array_stack(&stack);

    clear_array_stack(&stack);

    p_str("start");
    out_array_stack(&stack);
    p_i(stack.top);
    p_str("end");

    return 0;
}

126045888
-1
79 74 68 18 5 48 1 61 56 20 51 38 24 73 19 61 89 39 40 22
22 40 39 89 61 19 73 24 38 51 20 56 61 1 48 5 18 68 74 79
0
43 98 56 60 96 74 75 72 10 80 52 89 6 21 7 63 69 60 25 77 80 28 67 56 1 86 18 91 78 10
start
-1
end