环形缓冲队列

    项目中需要线程之间共享一个缓冲FIFO队列，一个线程往队列中添数据，另一个线程取数据（经典的生产者-消费者问题）。开始考虑用STL的vector容器, 但不需要随机访问，频繁的删除最前的元素引起内存移动，降低了效率。使用LinkList做队列的话，也需要频繁分配和释放结点内存。于是自己实现一个有限大小的FIFO队列，直接采用数组进行环形读取。

    队列的读写需要在外部进程线程同步（另外写了一个RWGuard类, 见另一文）

到项目的针对性简单性，实现了一个简单的环形缓冲队列，比STL的vector简单

PS: 第一次使用模板，原来类模板的定义要放在.h 文件中， 不然会出现连接错误。

 template <class _Type>
class CShareQueue 
{
public:
 CShareQueue();
 CShareQueue(unsigned int bufsize);
 virtual ~CShareQueue();

 _Type pop_front();
 bool push_back( _Type item);
 //返回容量
 unsigned int capacity() {  //warning:需要外部数据一致性
  return m_capacity;
 }
 //返回当前个数
 unsigned int size() {   //warning:需要外部数据一致性
  return m_size;
 }
 //是否满   //warning: 需要外部控制数据一致性
 bool IsFull() {
  return (m_size >= m_capacity);
 }

 bool IsEmpty() {
  return (m_size == 0);
 }

protected:
 UINT m_head;
 UINT m_tail;
 UINT m_size;
 UINT m_capacity;
 _Type *pBuf;

};

template <class _Type>
CShareQueue<_Type>::CShareQueue() : m_head(0), m_tail(0), m_size(0)
{
 pBuf = new _Type[512]; //默认512
 m_capacity = 512;
}

template <class _Type>
CShareQueue<_Type>::CShareQueue(unsigned int bufsize) : m_head(0), m_tail(0)
{
 if( bufsize > 512 || bufsize < 1)
 {
  pBuf = new _Type[512];
  m_capacity = 512;
 }
 else
 {
  pBuf = new _Type[bufsize];
  m_capacity = bufsize;
 }
}

template <class _Type>
CShareQueue<_Type>::~CShareQueue()
{
 delete[] pBuf;
 pBuf = NULL;
 m_head = m_tail = m_size = m_capacity = 0;
}

//前面弹出一个元素
template <class _Type>
_Type CShareQueue<_Type>::pop_front()
{
 if( IsEmpty() )
 {
  return NULL;
 }
 _Type itemtmp;
 itemtmp = pBuf[m_head];
 m_head = (m_head + 1) % m_capacity;
 --m_size;
 return itemtmp;

}

//从尾部加入队列
template <class _Type>
bool CShareQueue<_Type>::push_back( _Type item)
{
 if ( IsFull() )
 {
  return FALSE;
 }
 pBuf[m_tail] = item;
 m_tail = (m_tail + 1) % m_capacity;
 ++m_size;
 return TRUE;
}

#endif // !defined(_DALY_CSHAREQUEUE_H_)