Logical Error in Circular Queue (Data Structures) - c++11

Question

I was trying to run it, no matter what i insert into the queue and what the quantity of numbers inserted, it just does not display the circular queue.
These are some points over which i want a clarification and/or correction, would appreciate a response.
in the below code, in the function Insert_in_Cqueue(), towards the end, there is a statement 'rear++; Cqueue[rear] = ele;' , Does rear++ signify that we are moving forward towards the front from the rear, as that is how we insert in a circular queue?
in the function Del_from_Cqueue(), towards the end, there is a statement 'front++', all that it implies is that by incrementing 'front', we just lose track of the element concerned in that particular run of the function del_from_cqueue(), essentially implying that we have deleted the element which we wished to?
The code :
#include<iostream>
#include<conio.h>
#include<process.h>
using namespace std;
int Insert_in_CQueue(int[], int);
void Display(int[], int, int);
int Del_from_CQueue(int CQueue[]);
void main()
{
const int size = 7;
int CQueue[size];
int Item, res, ch, front = -1, rear = -1;
do
{
cout << "\t\t\t Circular Queue Menu\n";
cout << "\t 1. Insert\n";
cout << "\t 2. Delete\n";
cout << "\t 3. Display\n";
cout << "\t 4. Exit\n";
cout << "\n Enter your choice(1-4)";
cin >> ch;
switch (ch)
{
case 1: cout << "\t\t You have selected the option to 'Insert' in the Queue. ";
cout << "\n Enter item for insertion ";
cin >> Item;
res = Insert_in_CQueue(CQueue, Item);
if (res == -1)
{
cout << "\n Overflow encountered";
}
else
{
cout << "\n Now the circular Queue is : ";
Display(CQueue, front, rear);
}
break;
case 2: Item = Del_from_CQueue(CQueue);
cout << "\n Element deleted is : " << Item << endl;
Display(CQueue, front, rear);
break;
case 3: Display(CQueue, front, rear);
break;
case 4: break;
default: cout << "\n Valid choices are 1,2,3,4 only ";
break;
}
} while (ch != 4);
_getch();
return;
}
int Insert_in_CQueue(int CQueue[], int ele)
{
int front = -1, rear = -1;
const int size = 7;
if ((front == 0 && rear == (size - 1)) || (front == rear + 1)) //the
second condition, as it is a circular queue, no end
{
return -1;
}
else if (rear == -1)
{
front = rear = 0;
}
else if (rear == size - 1)
{
rear = 0;
}
else
rear++;
CQueue[rear] = ele;
return 0;
}
void Display(int CQueue[], int front, int rear)
{
int i = 0;
const int size = 50;
cout << "\n Circular Queue is : \n" << "(Front shown as >>>, Rear as <<<
AND Free space as->\n";
if (front == -1)
return;
if (rear >= front)
{
for (i = 0; i < front; i++) cout << "-";
cout << ">>>";
for (i = 0; i < rear; i++) cout << CQueue[i] << "<---";
cout << CQueue[rear] << "<<<" << endl;
}
else
{
for (i = 0; i < rear; i++) cout << CQueue[i] << "<---";
cout << CQueue[rear] << "<<<";
for (i = 0; i < front; i++) cout << "-";
cout << ">>>";
for (i = front; i < size; i++) cout << CQueue[i] << "<---";
}
}
int Del_from_CQueue(int CQueue[])
{
int ret;
int front = -1, rear = -1;
const int size = 50;
if (front == -1) return -1;
else
{
ret = CQueue[front];
if (front == rear) front = rear = -1;
else if (front == size - 1)
front=0;
else front++;
}
return ret;
}

Answer 1

The standard way of checking if a circular queue is full is
if((rear+1)%size == front)
Queue is Full.
The standard way of checking if a circular queue is empty is
if(rear==front)
Queue is Empty.
Remember: In a circular queue, the queue is considered full when one space is still empty. This is done to differentiate between condition of empty and full.
You do no simply increment the front and the rear while inserting or deleting the values. The values of front and rear need to be zero when they reach the queue size.
Eg: With a queue size of 7, when front or rear reaches the value of 6, theit next value should be zero and not 7
So while inserting, you should use:
rear=(rear+1)%size;
CQueue[rear] = ele;
And while deleting, you should use:
ret = CQueue[front];
front=(front+1)%size;
Your answer:
Yes ! When circular queue is empty, both the front and the rear are together. As we insert elements in the queue, the rear increases and the front remains constant. Increasing the rear value while inserting does not mean that we are moving towards the front from the rear, but when the queue approaches to be full, the front and the rear come together.
For example: If you run in a circular path from a starting point, you first move away from the starting point, but as you tend to complete the run, you approach the starting line from the back. Same goes with the circular queue.