#include<stdio.h>
#include<stdlib.h>
typedef struct Queue
{
    int *pBase;
    int front;
    int rear;

}Queue;
//函数的声明
void inti(Queue *);//初始化
bool enqueue(Queue *,int val);//入队列
bool dele(Queue *);//出队列
void print(Queue *);//打印队列
bool full(Queue *);
bool empty(Queue *);
int length(Queue *);
int main()
{
   int k,f,val;
   Queue Q;
   printf("\nplease input f to choose flowing op,-1 to end");
      printf("\n1:inti(Q)");
      printf("\n2:enqueue(Q)");
      printf("\n3:dele(Q)");
      printf("\n4:print(Q)");
      scanf("%d",&f);
  while(f!=-1)
  {
      switch (f)
      { case 1:inti(&Q);break;
        case 2:printf("\nplease input val:\n");
               scanf("%d",&val);
               enqueue(&Q,val);break;
        case 3:dele(&Q);break;
        case 4:print(&Q);break;
         
      }
      printf("\nplease input f to choose flowing op,-1 to end");
      printf("\n1:inti(Q)");
      printf("\n2:enqueue(Q)");
      printf("\n3:dele(Q,val)");
      printf("\n4:print(Q)");
      scanf("%d",&f);
  }
   return 0;
}
void inti(Queue *pQ)
{
    pQ->pBase=(int *)malloc(6*sizeof(int));    //申请24个字节的，并返回第一个字节的地址，并且是指向整形数据的
    pQ->front=0;
    pQ->rear=0;
    printf("初始化队列成功!\n");
}
bool enqueue(Queue *pQ,int val)
{
    if(!full(pQ))
    {
        printf("队列已满，不能入队列!\n");
        return false;
    }else
    {
        pQ->pBase[pQ->rear]=val;
        pQ->rear=(pQ->rear+1)%6;
        printf("入队列成功!\n");
        return true;
    }        

}
bool dele(Queue *pQ)
{   
    int val;
    if(pQ->front==pQ->rear)
    {
        printf("队列为空!\n");
         return false;
    }
     val=pQ->pBase[pQ->front];
     pQ->front=(pQ->front+1)%6;;
     printf("出队列的整数为%d\n",val);
    return true;
}
void print(Queue *pQ)
{
    if(pQ->front==pQ->rear)
    {
        printf("队列为空!");
    }
    int i = pQ->front;
    while (i != pQ->rear)
    {
        printf("%d  ", pQ->pBase[i]);
        i = (i+1) % 6;
    }
    printf("\n");

    return;
}
bool full(Queue *pQ)
{
    if((pQ->rear+1)%6==pQ->front)
    {
       return false;
    }
    else
    {
        return true;
    }
}
int length(Queue *pQ)
{
      return (pQ->rear-pQ->front)%6;
}


为什么访问队尾队头的时候是这样访问 pQ->pBase[pQ->rear], pQ->pBase[pQ->front]，访问元素的这样访问 pQ->pBase[i]不是很理解，还有pQ->pBase=(int *)malloc(6*sizeof(int));，这个指针变量指向哪里，谢谢！

为什么访问队尾队头的时候是这样访问 pQ->pBase[pQ->rear], pQ->pBase[pQ->front]，访问元素的这样访问 pQ->pBase[i]不是很理解?

至于你的这个程序，pQ->pBase[i]这样通过下面访问是可以的。因为你在初始化中申请了6个元素的空间。
每个元素的空间都是顺序排列的，因此可以访问。

你可以试着修改一下，在初始化时，不为其申请空间，而是每次入队列前再申请空间。

//出队列这个函数，仅仅只是现实队列中的元素，元素并没有真正出队列
bool dele(Queue *pQ)
{  
    int val;
    if(pQ->front==pQ->rear)
    {
        printf("队列为空!\n");
         return false;
    }
     val=pQ->pBase[pQ->front];
     pQ->front=(pQ->front+1)%6;;
     printf("出队列的整数为%d\n",val);
    return true;
}

你说出队列这个函数，仅仅只是现实队列中的元素，元素并没有真正出队列，仔细想想也对
  bool out_queue(QUEUE * pQ, int * pVal)
{
    if ( emput_queue(pQ) )
    {
        return false;
    }
    else
    {
        *pVal = pQ->pBase[pQ->front];
        pQ->front = (pQ->front+1) % 6;

        return true;
    }
}
调用的时候
if ( out_queue(&Q, &val) )
    {
        printf("出队成功，队列出队的元素是: %d\n", val);
    }
    else
    {
        printf("出队失败!\n");
    }
这样行不行？

你说出队列这个函数，仅仅只是现实队列中的元素，元素并没有真正出队列，不是很懂，那应该怎么做呢

打一个很简单的比喻： 小时候玩具枪，压弹夹。
先进先出，后进后出.
当出了一颗子弹，弹夹里面就少了一颗，而且是最前面的那颗。
你的出栈，元素根本就没变。至于怎么做，不难啊，你想想吧！

这是顺序结构的循环队列，又不是链式结构的可以释放节点，顺序表好像无法操作吧，只能是取出元素在赋值

哦，实在不好意思，我还真把它当作链式队列来处理了，我的过错，在此道歉。

我在网上找了点资料，希望对你有点帮助。
http://ettc.sysu.
这个网站上面有一个 循环队列 进队，出对 动画模拟演示。

学习中。不过，数据结构中对循环队列介绍还算详细，好好看看吧，其实也挺好理解的。看楼主和各位大虾的讨论，这个循环队列怎么那么像数组，先申请24个字节（6个int），就像申请了长度为6的int数组，然后pQ->Base[]就像数组的操作。应该楼主这个就是按数组的处理方式处理的吧。