Circular queue

[lavender]

When define a maxQueue is 10, means it able to store 10 items in circular queue,but when I key in the 10 items, it show "Queue Full" in items number 10.
Where is the wrong in my code? Why it cannot store up to 10 items?

Output from my code:

Enter you choice: 1
Enter ID document to print : 21

Enter you choice: 1
Enter ID document to print : 22

Enter you choice: 1
Enter ID document to print : 23

Enter you choice: 1
Enter ID document to print : 24

Enter you choice: 1
Enter ID document to print : 25

Enter you choice: 1
Enter ID document to print : 26

Enter you choice: 1
Enter ID document to print : 27

Enter you choice: 1
Enter ID document to print : 28

Enter you choice: 1
Enter ID document to print : 29

Enter you choice: 1
Enter ID document to print : 30
Error: Queue Full




Here is my code;

#include <stdio.h>
#define maxQueue 10
 
typedef char BOOL;
typedef int itemType;
typedef struct QUEUE
{
    int head;
    int tail;
    int items[maxQueue];
}queue;
 
void initQueue(queue *);
BOOL emptyQueue(queue *);
BOOL fullQueue(queue *);
void insertQueue(itemType ,queue *);
void deleteQueue(itemType *,queue *);
void menu();
void SendToPrint(queue *);
void Print(queue *);
 
 
int main()
{
    queue nQ;
    int i = 0;
    //clrscr();
    initQueue(&nQ);
    do
    {
        menu();
        scanf("%d",&i);
        switch (i)
        {
            case 1:SendToPrint(&nQ);break;
 
            case 2:Print(&nQ);break;
 
            case 3:Exit(0);break;
 
            default:printf("\nERROR");break;
        }
    }while (i!=3);
}
 
void SendToPrint(queue *q)
{
    itemType nItem;
    printf("\n\nEnter ID document to print :");
    scanf("\t%d",&nItem);
    insertQueue(nItem,q);
 
    return;
}
 
void Print(queue *q)
{
    int i;
    BOOL state;
    printf("\n\nCheck printer buffer...");
 
 
    if(q->tail < q->head) 
        state = ((BOOL)(q->head - q->tail) > 4);
    else
        state = ((BOOL)(q->tail - q->head) > 4);
    if (state)
    {
        for (i = 0;i<5 ;i++)
        {
            printf("\nID Document print  %d",q->items[q->head]);
            deleteQueue(q->items[q->head],q);
 
        }
    }
    else
        printf("\nError Printer buffer no enough\n");
    return;
}
 
void menu()
{
    printf("\n****Printer Spooling****\n");
    printf("1 - Sent document to print\n");
    printf("2 - Print document\n");
    printf("3 - Exit\n");
    printf("Please enter your choice :");
}
 
void initQueue(queue *q)
{
   q->head = 0;
   q->tail = 0;
}
 
BOOL emptyQueue(queue *q)
{
    return ((BOOL)(q->head == q->tail));
}
 
BOOL fullQueue(queue *q)
{
    return ((BOOL)(((q->tail-1) % maxQueue) == q->head));
 
}
 
void insertQueue(itemType nItem,queue *q)
{
    if (fullQueue(q))
        printf(" Error : Queue Full\n");
    else
    {
 
            q->items[q->tail] = nItem;
            q->tail = (q->tail+1)%maxQueue;
 
 
    }
}
 
void deleteQueue(itemType *nItem,queue *q)
{
    if (emptyQueue(q))
        printf(" Error : Queue Empty\n");
    else
    {
 
        q->head = (q->head + 1) % maxQueue;
 
    }
}

[DeMan]

Have you tried setting up a function to display eveery item in the queue? This is always a very good way to see if something fishy is going on

[Banfa]

The way you have set up your circular buffer (which is fairly common as it gets round some other problems mainly distinguishing between an empty list and a full list) you have to have at least 1 empty entry in the list. So if the list is 10 items long it can only hold 9 items in it.

This comes from the maths in your fullQueue function, the queue is full if the tail is 1 item ahead of the head, since the tail points to the next item to write and not a filled in item it must therefore point to an empty slot so your queue must contain 1 unused slot.

It you changed the queue full definition by removing the -1 from fullQueue then you would find the maths in fullQueue resolve to exactly the same test as emptyQueue, you would not be able to distinguish between an empty queue and a full queue.

Often it is just accepted that the queue holds size-1 items as it makes the code a lot simpler for not too much memory overhead, especially since often if you are using a circular buffer you do not want to get to the situation of having a full queue anyway as this is often some sort of error.