编写程序，定义队列类模板，遵循“先进先出”数据操作原则

///////////////////////////////////////////////////////////////////////////////
#define define_Type template
#define data_Type VUALESTYPE
//*/////////////////////////////////////////////////////////////////////////////
//**节点************************************************************************
//*/////////////////////////////////////////////////////////////////////////////
///栈、队列节点结构体
define_Type
class _node
{
public:
data_Type m_data;//数据类型
_node *next;//下一个节点指针
};

#define CNode _node
#define LPCNode _node *
////////////////////////////////////////
//*///////////////////////////////////////////////////////////////////////////////////////////////////////
/*

类定义部分。

*/
//*////////////////////////////////////////////////////////////////////////////////////////////////////////
//*/////////////////////////////////////////////////////////////////////////////
//****队列********************************************************************
//*/////////////////////////////////////////////////////////////////////////////
define_Type
class CQueueUserDefine
{
LPCNode rear_queue_node;//队尾
long queue_size;
long current_node;

public:
CQueueUserDefine(void);
virtual ~CQueueUserDefine(void);

data_Type PopQueue(data_Type *desData = NULL);
bool PushQueue(const data_Type new_data);
void *GetTop() const ;
long GetQueueSize() const ;
data_Type GetQueueHead() ;
data_Type GetQueueRear() const ;
data_Type GetNextQueueNode() ;
data_Type GetQueueNodeData(const long current_node) ;

private :
bool Empty() const ;
void *MallocMem();
bool FreeMem(void *memory) const ;
void *GetSecondHeadNode(void);
};

//*///////////////////////////////////////////////////////////////////////////////////////////////////////
//****队列************************************************************************************************
//*////////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
define_Type
CQueueUserDefine::CQueueUserDefine()
{
queue_size = current_node = 0;
rear_queue_node = NULL;
}

define_Type
CQueueUserDefine::~CQueueUserDefine()
{
while (!Empty())
{
PopQueue();
}
}

////////////////////////////////////////////////////////
/*
作用：判断是否为空。
*/
////////////////////////////////////////////////////////
define_Type
bool CQueueUserDefine::Empty(void) const
{
if (rear_queue_node == NULL || queue_size <= 0)
return true;
return false;
}

////////////////////////////////////////////////////////
/*
作用：分配内存。
*/
////////////////////////////////////////////////////////
define_Type
void *CQueueUserDefine::MallocMem()
{
CNode *temp_struct = (LPCNode)malloc(sizeof(CNode));
temp_struct->next = NULL;

return (void*)temp_struct;
}

////////////////////////////////////////////////////////
/*
作用：释放内存。
*/
////////////////////////////////////////////////////////
define_Type
bool CQueueUserDefine::FreeMem(void *memory) const
{
free(memory);
return true;
}

////////////////////////////////////////////////////////
/*
作用：得到倒数第二个头节点的指针 。
*/
////////////////////////////////////////////////////////
define_Type
void *CQueueUserDefine::GetSecondHeadNode(void)
{
if (!Empty())
{
LPCNode temp_data = rear_queue_node;
LPCNode temp_data_temp = rear_queue_node;

while (rear_queue_node->next != NULL && !Empty())
{
temp_data_temp = rear_queue_node;
rear_queue_node = rear_queue_node->next;
}

rear_queue_node = temp_data;

return (void *)(temp_data_temp);
}
return NULL;
}

////////////////////////////////////////////////////////
/*
作用：出队列。
*/
////////////////////////////////////////////////////////
define_Type
data_Type CQueueUserDefine::PopQueue(data_Type *desData)
{
if (!Empty())
{
LPCNode temp_data = (LPCNode)GetSecondHeadNode();
LPCNode temp = temp_data;

if (temp_data == NULL) return NULL;
{
if (temp_data->next != NULL)
temp_data = temp_data->next;
if (desData != NULL)
{
ZeroMemory((void*)desData,sizeof (desData));
memcpy((void*)desData,(void *)(&(temp_data->m_data)),sizeof (temp_data->m_data));
}
}

LPCNode temp_data_temp = rear_queue_node;
while (rear_queue_node != temp_data && !Empty())
rear_queue_node = rear_queue_node->next;
FreeMem(rear_queue_node);
if (temp != temp_data) temp->next = NULL;
else temp_data_temp = NULL;
rear_queue_node = NULL;
rear_queue_node = temp_data_temp;

queue_size--;
if (desData != NULL)
return *desData;
}
return NULL;
}

/////////////////////////////////////////////////////////////////////////
/*
作用：入队列。
*/
/////////////////////////////////////////////////////////////////////////
define_Type
bool CQueueUserDefine::PushQueue(const data_Type new_data)
{
LPCNode node_temp = (LPCNode)MallocMem();
if (memcpy((void*)(&(node_temp->m_data)),(void *)(&new_data),sizeof (new_data)) != NULL)
{
node_temp->next = rear_queue_node;
rear_queue_node = node_temp;
queue_size++;

return true;
}
return false;
}

/////////////////////////////////////////////////////////////////////////
/*
作用：得到队列长度。
*/
/////////////////////////////////////////////////////////////////////////
define_Type
long CQueueUserDefine::GetQueueSize() const
{
return size_stack;
}

/////////////////////////////////////////////////////////////////////////
/*
作用：得到队列头。
*/
/////////////////////////////////////////////////////////////////////////
define_Type
data_Type CQueueUserDefine::GetQueueHead()
{
LPCNode temp_data = (LPCNode)GetSecondHeadNode();
if (temp_data->next != NULL) return temp_data->next->m_data;
else return temp_data->m_data;
}

/////////////////////////////////////////////////////////////////////////
/*
作用：得到队列尾。
*/
/////////////////////////////////////////////////////////////////////////
define_Type
data_Type CQueueUserDefine::GetQueueRear() const
{
return rear_queue_node->m_data;
}

/////////////////////////////////////////////////////////////////////////
/*
作用：遍历队列。
*/
/////////////////////////////////////////////////////////////////////////
define_Type
data_Type CQueueUserDefine::GetNextQueueNode()
{
return GetQueueNodeData(current_node ++ );
}

/////////////////////////////////////////////////////////////////////////
/*
作用：遍历队列。
*/
/////////////////////////////////////////////////////////////////////////
define_Type
data_Type CQueueUserDefine::GetQueueNodeData(const long current_node_temp)
{
long _current = 0;
LPCNode temp_node = rear_queue_node;
LPCNode temp = NULL;

current_node = current_node_temp;
if (current_node_temp > queue_size) current_node = 1;

while (current_node > ++_current
&& rear_queue_node != NULL)
rear_queue_node = rear_queue_node->next;
temp = rear_queue_node;
rear_queue_node = temp_node;

current_node = _current+1;
if (current_node > queue_size) current_node = 1;

if (temp != NULL)
return temp->m_data;
return rear_queue_node->m_data;
}

这些函数实现只能在.h文件内……