简单的循环队列实现 不足之处请留言指出

以下是头文件：

#pragma once
#ifndef __LIST_H__
#define __LIST_H__

#define _CRT_SECURE_NO_WARNINGS

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

#endif

以下是代码实现：

#include "list.h"

#define MAX_QUEUE 10    

//---------循环队列--------
//从队尾入队，队头出队
//最大长度为  MAX_QUEUE-1  ，留下一个空位做判空等处理
typedef int ElemType;
typedef struct {
	ElemType* elem;   //存储空间elem
	int front;		//头指针，若队列不为空，指向头元素
	int rear;		//尾指针，若队列不为空，指向队尾的下一个指针
}SqQueue, *pSqQueue;

enum position { ERROR, OK, OVERFLOW = -2 };  //0 1 -2

//---------循环队列的基本操作--------
int Init_Queue(SqQueue* Q);    //初始化队列
int Len_Queue(const SqQueue* Q);    //队列的长度
int EnQueue(SqQueue* Q, ElemType e);    //入队操作，成功返回OK
ElemType DeQueue(SqQueue* Q, ElemType* e);   //出队操作，成功返回元素，失败返回ERROR
void TraverQueue(const SqQueue* Q);     //遍历队列
void test7();

//int main()
//{
//	printf("------------------循环队列测试------------------\n");
//	test7();
//	system("pause");
//	return 0;
//}

void test7()
{
	SqQueue Que;
	int elem=0,state=0;
	Init_Queue(&Que);
	printf("full queue:\n");
	for (int i = 0; i < MAX_QUEUE; i++)
	{
		EnQueue(&Que, i); 
	}
	TraverQueue(&Que);

	printf("insert full queue:%d\n", EnQueue(&Que, 99));
	
	state = DeQueue(&Que, &elem); printf("delete queue:%d---elem:%d\n", state, elem);
	EnQueue(&Que, 2);
	EnQueue(&Que, 6);	
	DeQueue(&Que, &elem);

	state = DeQueue(&Que, &elem);  printf("delete queue:%d---elem:%d\n", state, elem);

	EnQueue(&Que, 6);
	EnQueue(&Que, 88);
	TraverQueue(&Que);
	DeQueue(&Que, &elem);  
	TraverQueue(&Que);
	printf("queue length:%d\n", Len_Queue(&Que));
}

int Init_Queue(SqQueue* Q)
{
	assert(Q);    //判断seql是否有效
	Q->elem = (ElemType*)malloc(MAX_QUEUE * sizeof(ElemType));
	if (!Q->elem) exit(OVERFLOW);
	Q->front = Q->rear = 0;       //队列为空时，头尾指针指向同一空间
	return OK;
}

int Len_Queue(const SqQueue* Q)
{
	assert(Q);
	return (Q->rear - Q->front + MAX_QUEUE) % MAX_QUEUE;
}

int EnQueue(SqQueue* Q, ElemType e)
{
	assert(Q);
	if ((Q->rear + 1) % MAX_QUEUE == Q->front)    //队列判满,留一个预留空间
	{
		return ERROR;
	}
	Q->elem[Q->rear] = e;
	Q->rear = (Q->rear + 1) % MAX_QUEUE;    //下移
	return OK;
}

int DeQueue(SqQueue* Q, ElemType* e)
{
	assert(Q);
	if (Q->front == Q->rear)     //队列判空
	{
		return ERROR;
	}
	*e = Q->elem[Q->front];
	Q->front = (Q->front + 1) % MAX_QUEUE;
	return OK;
}

void TraverQueue(const SqQueue* Q)
{
	assert(Q);
	ElemType temp = Q->front;
	while ((Q->rear - temp + MAX_QUEUE) % MAX_QUEUE)
	{
		printf("%d  ", Q->elem[temp]);
		temp = (temp + 1) % MAX_QUEUE;     //temp指针下移  遍历操作不会影响队列原来的指针位置
	}
	printf("\n");
}