Implementacion de una pila en C

std_stack.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

//definicion de estructuras
typedef struct nodo {
    int valor;
    struct nodo *siguiente;
    //struct nodo *anterior;
} Nodo;

typedef struct stack {
    int total;
    Nodo *primero;
    Nodo *ultimo;
} Stack;

//prototipo de funciones
Stack *initialize(); //inicializar la pila
int isEmpty(Stack *stack); //comprobar que la pila se encuentra vacia
void push(Stack *stack, int valor); //agregar un nuevo elemento a la pila
Nodo *pop(Stack *stack); //remover el elemento agregado mas reciente
Nodo *peek(Stack *stack); //consultar el elemento agregado mas reciente

int main() {
    Stack *stack = initialize();
    push(stack, 10);
    printf("peek: %d\n", peek(stack)->valor); //10
    push(stack, 20);
    push(stack, 30);
    push(stack, 50);
    printf("peek: %d\n", peek(stack)->valor); //50

    Nodo *nodo = stack->primero;
    while(nodo != NULL) {
        printf("[] => %d\n", nodo->valor);
        nodo = nodo->siguiente;
    }

    printf("total: %d\n", stack->total); //4 elementos
    printf("pop: %d\n", pop(stack)->valor); //quito el 50 de la pila
    printf("peek: %d\n", peek(stack)->valor); //el inicio de la pila contiene 30
    printf("pop: %d\n", pop(stack)->valor); //quito el 30 de la pila
    printf("pop: %d\n", pop(stack)->valor); //quito el 20 de la pila
    printf("pop: %d\n", pop(stack)->valor); //quito el 10 de la pila
    printf("pop: %p\n", pop(stack)); //null
    printf("total: %d\n", stack->total); //0 elementos
    return 0;
}

//definicion de funciones
Stack *initialize() {
    Stack *stack = malloc(sizeof(Stack));
    stack->total = 0;
    stack->primero = NULL;
    stack->ultimo = NULL;
    return stack;
}

int isEmpty(Stack *stack) {
    assert(stack != NULL && stack->total >= 0);
    return stack->total == 0;
}

void push(Stack *stack, int valor) {
    Nodo *nodo = malloc(sizeof(Nodo));
    nodo->valor = valor;
    nodo->siguiente = NULL;
    //nodo->anterior = NULL;

    if(isEmpty(stack)) {
        stack->primero = nodo;
        stack->ultimo = nodo;
        stack->total = 1;
    } else {
        nodo->siguiente = stack->primero;
        //stack->primero->anterior = nodo;
        stack->primero = nodo;
        stack->total++;
    }
}

Nodo *pop(Stack *stack) {
    Nodo *nodo = NULL;

    if(!isEmpty(stack)) {
        if(stack->total == 1) { 
            nodo = malloc(sizeof(Nodo));

            //copia el inicio de la pila en un nodo temporal
            memcpy(nodo, stack->primero, sizeof(Nodo));

            //libero la memoria
            free(stack->primero);

            /*
            detalle importante: para WINDOWS se debe asignar explicitamente el NULL
            en los pivotes, evitando almacenar direcciones a memoria basura
            */
            stack->primero = NULL;
            stack->ultimo = NULL;
            stack->total = 0;       
        } else {
            nodo = malloc(sizeof(Nodo));
            //copio el inicio de la pila en un nodo temporal
            memcpy(nodo, stack->primero, sizeof(Nodo));

            //libero la memoria
            free(stack->primero);

            //el primero elemento de la pila es removido, dejando al segundo en su lugar
            stack->primero = stack->primero->siguiente;
            stack->total--;
        }
    }

    return nodo;
}

Nodo *peek(Stack *stack) {
    Nodo *nodo = NULL;

    if(!isEmpty(stack)) 
        nodo = stack->primero;

    return nodo;
}