C++ 通过链表实现的栈

#ifndef __LINKED_LIST_STACK_C2025__
#define __LINKED_LIST_STACK_C2025__

typedef int linked_list_stack_data;

typedef struct linked_list_stack_node_t
{
    linked_list_stack_data data;
    struct linked_list_stack_node_t *next;
} linked_list_stack_node, *linked_list_stack_ptr, *linked_list_stack_node_ptr;

bool is_empty_linked_list_stack(linked_list_stack_ptr stack);



void push_linked_list_stack(linked_list_stack_ptr stack, linked_list_stack_data data);

linked_list_stack_data pop_linked_list_stack(linked_list_stack_ptr stack);

void out_linked_list_stack(linked_list_stack_ptr stack);

void clear_linked_list_stack(linked_list_stack_ptr stack);

linked_list_stack_ptr create_linked_list_stack();

linked_list_stack_node_ptr make_linked_list_node(linked_list_stack_data data);

void free_linked_list_stack(linked_list_stack_ptr stack);

#define destroy_linked_list_stack(stack)   \
    do                                     \
    {                                      \
        if (stack)                         \
        {                                  \
            free_linked_list_stack(stack); \
            stack = null;                  \
        }                                  \
    } while (0)

#endif

#include "../util.h"
#include "linked_list_stack.h"

bool is_empty_linked_list_stack(linked_list_stack_ptr stack)
{
    return !stack || !stack->next;
}

void push_linked_list_stack(linked_list_stack_ptr stack, linked_list_stack_data data)
{
    if (stack)
    {
        linked_list_stack_node_ptr node = make_linked_list_node(data);
        node->next = stack->next;
        stack->next = node;
    }
}

linked_list_stack_data pop_linked_list_stack(linked_list_stack_ptr stack)
{
    linked_list_stack_data d = 0;
    if (!is_empty_linked_list_stack(stack))
    {
        linked_list_stack_node_ptr p = stack->next;
        stack->next = p->next;
        d = p->data;
        free(p);
        p = null;
    }
    return d;
}

void out_linked_list_stack(linked_list_stack_ptr stack)
{
    if (!is_empty_linked_list_stack(stack))
    {
        linked_list_stack_node_ptr p = stack->next;
        while (p->next)
        {
            printf("%d ", p->data);
            p = p->next;
        }
        printf("%d\n", p->data);
    }
}

void clear_linked_list_stack(linked_list_stack_ptr stack)
{
    if (!is_empty_linked_list_stack(stack))
    {
        linked_list_stack_node_ptr p = stack->next;
        free_linked_list_stack(p);
        stack->next = null;
    }
}

linked_list_stack_node_ptr make_linked_list_node(linked_list_stack_data data)
{
    linked_list_stack_node_ptr p = malloc(sizeof(linked_list_stack_node));
    if (p)
    {
        p->data = data;
        p->next = null;
    }
    return p;
}

linked_list_stack_ptr create_linked_list_stack()
{
    return make_linked_list_node(0);
}

void free_linked_list_stack(linked_list_stack_ptr stack)
{
    if (stack)
    {
        linked_list_stack_node_ptr p = stack;
        while (p)
        {
            linked_list_stack_node_ptr r = p;
            p = p->next;
            r->next = null;
            free(r);
            r = null;
        }
    }
}

#include "../util.h"
#include "linked_list_stack.h"

int next_rand_limit_max(int max)
{
    static bool not_inited = true;
    if (not_inited)
    {
        srand(time(null));
        not_inited = false;
    }
    return rand() % max;
}

int main()
{

    linked_list_stack_ptr stack = create_linked_list_stack();

    p_i(is_empty_linked_list_stack(stack));

    p_str("start");
    out_linked_list_stack(stack);
    p_str("end");

    for (int i = 0; i < 20; i++)
    {
        push_linked_list_stack(stack, i);
        // printf("%d ", i);
    }
    // printf("%d\n", 20);
    push_linked_list_stack(stack, 20);
    out_linked_list_stack(stack);

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

    p_i(is_empty_linked_list_stack(stack));

    for (int i = 0; i < 30; i++)
    {
        push_linked_list_stack(stack, next_rand_limit_max(100));
    }

    out_linked_list_stack(stack);

    clear_linked_list_stack(stack);

    p_i(is_empty_linked_list_stack(stack));

    p_str("start");
    out_linked_list_stack(stack);
    p_str("end");

    destroy_linked_list_stack(stack);

    p_a(stack);

    return 0;
}

1
start
end
20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
0
1
73 4 36 75 35 43 98 83 65 81 78 94 91 72 60 57 74 41 62 31 94 77 28 95 30 90 86 51 68 7
1
start
end
(nil)