循环队列代码（支持对共享内存的操作）

//
//
//  CTfxQueue V1.0.3
//  循环队列（支持对共享内存的操作）
//
// Copyright (c) 2005 - 2006 TRUEWAY(TM).
// All rights reserved.
// 
//  Written By Trueway Lee
//
// E-Mail: truewaylee@163.com
// MSN: truewaylee@hotmail.com
//
//--------------------------------------------------------------------
// 版本历史:
//--------------------------------------------------------------------
// V1.0.0 2005.08.31 完成V1.0版本，创建程序框架
// V1.0.1 2005.09.02 完成V1.0.1版本, 删除带参数的构造子,
//      该构造子将导致 new 对象时不成功
// V1.0.2 2005.09.21 调整构造子, 支持带参数自动创建内部缓存
// V1.0.3 2005.12.31 修正Clear()函数，在多字节类型缓存下存在的BUFFER长度计算问题
//
//

#ifndef  __TFX__QUEUE__H__
#define  __TFX__QUEUE__H__
 

#include <windows.h>

#pragma  once

// 默认缓存大小
#define  BYTE_BUFFER_SIZE  4096

template <class T>
class CTfxQueue
{
public:
 // 构造子

 CTfxQueue(const int buffsize = BYTE_BUFFER_SIZE)
 {
  _Init();

  Create(buffsize, NULL);
  
 }
 
  int Create(const int buffsize, T * buff= NULL)
 {
  int iret = 0;

  m_max_len = buffsize;
  if ( m_max_len < 1 ) m_max_len = 100;

  if (buff == NULL ) // 由内部申请空间
  {
   m_bFreeMem = TRUE;
    this->m_buff = new T[m_max_len];

   if (this->m_buff == NULL) return -1;
  }
  else // 缓存空间由外部传入, 此时在类析构时不负责删除缓存
  {

   //  下面是传入共享内存地址作为循环队列的缓存
   // 需要 SFMMem.h 和  SFMMem.cpp
   //  m_psfm = new CSFMServer(NULL, "__aa__", 100);
   // m_pbuff = new CTfxByteBuffer(100, (LPBYTE)m_psfm->GetBuffer());

   m_bFreeMem = FALSE;
    this->m_buff = buff;
  }
  
  return 0;

 }
 
 // 析钩子
 virtual ~CTfxQueue()
 {
  _Init();
  
  if (m_bFreeMem) delete [] m_buff ;
 }

 // 推入一个元素
 int Push(const T & a_data)    
 {
  if ( this->IsFull() ) return -1;
  
  m_buff[m_nTail] = a_data;
  m_nTail = ( m_nTail + 1) % m_max_len;
  
  m_buff_len ++;

  return 0;
 }
 
 // 弹出一个元素
 int Pop(T * p_data)     
 {
  if ( this->IsEmpty() ) return -1;

  *p_data = m_buff[m_nFront];
  m_nFront = ( m_nFront + 1) % m_max_len;
   
  m_buff_len --;

  return 0;
 }

 // 推入一组元素
 int PushBuff(T *  p_data, int len) 
 {
   int li_pushed_len = 0;

  for ( int i = 0 ; i < len ; i ++)
  {
   int ret2 = Push(p_data[i]);
    
   if ( ret2 != 0) break;

   li_pushed_len ++;
  }
  
  return li_pushed_len;
 }

 // 弹出一组元素
 int PopBuff(T *  p_data, int len) 
 {
   int li_poped_len = 0;

  for ( int i = 0 ; i < len ; i ++)
  {
   int ret2 = Pop(p_data + li_poped_len );
    
   if ( ret2 != 0) break;

   li_poped_len ++;
  }
  
  return li_poped_len;
 }
 
 // 获得当前缓存中的数据, 但不改变缓存内容
 int GetBuff(T *  p_data )  
 {
   int li_len = 0;
  int nIndex = m_nFront;

  while ( nIndex != m_nTail )
  {  
   * (p_data + li_len ) = m_buff[nIndex];
   
   nIndex = ( nIndex + 1 ) % m_max_len;
   li_len ++;

  } 
  return li_len;
 }

 // 清除缓存内容
 int Clear()      
 {
  this->m_buff_len = 0;
  this->m_nFront = 0;
  this->m_nTail = 0;

  //memset(m_buff, 0, m_max_len);
  memset(m_buff, 0, m_max_len * sizeof(T));
  return 0;
 }

 // 获得缓存最大长度
 int GetBuffLength()     
 {
  return (this->m_max_len - 1);
 }

 // 获得实际数据长度
 int GetDataLength()     
 {
   return this->m_buff_len;
 }

 // 当前缓存是否为空
 BOOL IsEmpty()      
 {
   return (this->m_buff_len == 0 );
 }

 // 当前缓存是否已满
 BOOL IsFull()      
 {
  return (this->m_buff_len >= this->m_max_len - 1 );
 }

protected:

 int _Init()
 {
  this->m_buff_len = 0;
  this->m_nFront = 0;
  this->m_nTail = 0;
  this->m_max_len = 0 ;
  this->m_buff = NULL;

  return 0;
 }

private:
 

 T  *m_buff;

 int  m_nFront;    // 队首
 int  m_nTail;    // 对尾巴
 int  m_buff_len;    // 缓存长度
 int  m_max_len;    // 最长长度

 BOOL    m_bFreeMem;    // 是否由内部是否内存

 
};

// 常规定义
typedef  CTfxQueue<BYTE>  CTffByteBuffer, CTfxByteBuffer;
typedef  CTfxQueue<WORD>  CTffWordBuffer, CTfxWordBuffer;
typedef  CTfxQueue<long>  CTffLongBuffer, CTfxLongBuffer;

#endif // __TFX__QUEUE__H__