Очередь как кольцевой массив

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
 
/****************** STACK **********************************/
 
typedef struct STACK {
    int * buf;
    int size;
    int top;
} * stack_t;
 
stack_t new_stack(int size) {
    stack_t stack;
    
    if ( size < 1 || ! ( stack = malloc(sizeof(struct STACK)) ) )
        return NULL;
    
    if ( ! ( stack->buf = malloc(sizeof(int) * size) ) ) {
        free(stack);
        return NULL;
    }
    
    stack->size = size;
    stack->top = 0;
    
    return stack;
}
 
int stack_is_full(stack_t stack) {
    return ( stack->top >= stack->size );
}
 
int stack_is_empty(stack_t stack) {
    return ( stack->top <= 0 );
}
 
void stack_push(stack_t stack, int value) {
    assert(stack && ! stack_is_full(stack));
    stack->buf[stack->top++] = value;
}
 
int stack_pop(stack_t stack) {
    assert(stack && ! stack_is_empty(stack));
    return stack->buf[--(stack->top)];
}
 
void delete_stack(stack_t stack) {
    assert(stack);
    free(stack->buf);
    free(stack);
}
 
/************************ QUEUE ****************************/
 
typedef struct QUEUE {
    int * buf;
    int size;
    int head;
    int tail;
    int empty;
} * queue_t;
 
queue_t new_queue(int size) {
    queue_t queue;
    
    if ( size < 1 || ! ( queue = malloc(sizeof(struct QUEUE)) ) )
        return NULL;
    
    if ( ! ( queue->buf = malloc(sizeof(int) * size) ) ) {
        free(queue);
        return NULL;
    }
    
    queue->size = size;
    queue->head = 0;
    queue->tail = 0;
    queue->empty = 1;
    
    return queue;
}
 
int queue_is_full(queue_t queue) {
    return ( queue->tail == queue->head && ! queue->empty );
}
 
int queue_is_empty(queue_t queue) {
    return ( queue->empty );
}
 
void queue_push(queue_t queue, int value) {
    assert(queue && ! queue_is_full(queue));
    queue->buf[queue->tail++] = value;
    queue->tail %= queue->size;
    queue->empty = 0;
}
 
int queue_shift(queue_t queue) {
    int ret;
    assert(queue && ! queue_is_empty(queue));
    
    ret = queue->buf[queue->head++];
    queue->head %= queue->size;
    queue->empty = ( queue->head == queue->tail );
    
    return ret;
}
 
void delete_queue(queue_t queue) {
    assert(queue);
    free(queue->buf);
    free(queue);
}
 
/************************* MAIN ******************************/
 
#define STACK_SIZE (10)
#define QUEUE_SIZE (4)
 
int main(void) {
    stack_t stack;
    queue_t queue;
    int i;
    
    assert(stack = new_stack(STACK_SIZE));
    assert(queue = new_queue(QUEUE_SIZE));
    
    for ( i = 0; i < STACK_SIZE; ++i )
        stack_push(stack, i + 1);
    
    while ( ! stack_is_empty(stack) ) {
        i = stack_pop(stack);
 
        if ( queue_is_full(queue) )
            while ( ! queue_is_empty(queue) )
                printf("%d ", queue_shift(queue));
                
        queue_push(queue, i);
    }
    while ( ! queue_is_empty(queue) )
        printf("%d ", queue_shift(queue));
    
    delete_stack(stack);
    delete_queue(queue);
    
    return(0);
}