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

原创 2006年05月20日 02:55:00

//////////////////////////////////////////////////////////////////////
//
//  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__

生产者-消费者-信号量-共享内存-循环队列

代码转自别处,稍有修改,主要是宏定义,我觉得不够直观的地方给改了,逻辑没变 用信号量来控制队列 #include #include #include #include #include #i...
  • shuimuyq
  • shuimuyq
  • 2016年04月20日 14:48
  • 669

共享内存循环形队列池设计

1、 简述     队列是一种先进先出(FIFO)的线性表数据结构,常见的操作如在表的尾部插入,在头部删除数据。队列的类型有链表结构、固定缓冲区结构等。常用的队列空间都是动态地从堆中申请,在数据...
  • liuxuezong
  • liuxuezong
  • 2013年04月23日 21:53
  • 5383

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

//////////////////////////////////////////////////////////////////////////  CTfxQueue V1.0.3//  循环队列...
  • truewaylee
  • truewaylee
  • 2006年05月20日 02:55
  • 1480

使用消息队列与共享内存完成一个简单的终端聊天程序

  • 2016年08月09日 23:36
  • 459KB
  • 下载

共享内存循环形队列池设计

1、 简述 队列是一种先进先出(FIFO)的线性表数据结构,常见的操作如在表的尾部插入,在头部删除数据。队列的类型有链表结构、固定缓冲区结构等。常用的队列空间都是动态地从堆中申请,在数据量操...
  • liyayazuiqiang
  • liyayazuiqiang
  • 2016年12月01日 10:47
  • 440

以队列的形式使用共享内存

共享内存允许多个进程使用某一段存储区,数据不需要在进程之间复制,多个进程都把该内存区域映射到自己的虚拟地址空间,直接访问该共享内存区域,从而可以通过该区域进行通信,是一种速度很快IPC。下面是共享内存...
  • keheinash
  • keheinash
  • 2016年05月14日 17:22
  • 1523

进程间通讯的消息队列和共享内存方式的实现

qt,进程间通讯,消息传递模式,共享内存模式
  • zhangxufei
  • zhangxufei
  • 2016年02月18日 15:29
  • 2071

boost进程间通信常用开发一篇全(消息队列,共享内存,信号)

敏捷开发大家想必知道而且评价甚高,缩短开发周期,提高开发质量。将大工程独立为不同的小app开发,整个开发过程,程序可用可测,所以提高了整体的质量。基于这种开发模式和开发理念,进程间通信必然是童鞋们必掌...
  • luopeiyuan1990
  • luopeiyuan1990
  • 2014年05月23日 11:02
  • 5954

采用顺序存储实现循环队列的初始化、入队、出队操作。

//////////////////////下面为循环队列 #include #include #define OVERFLOW -2 #define MAXQSIZE 100  /*队列的最...
  • cddchina
  • cddchina
  • 2012年04月19日 22:46
  • 24254

C++容器模板在共享内存中的使用

本文用于探讨在共享内存中使用容器的好处,以及几种在共享内存中C++模板容器的方法。 1 为什么要在共享内存中使用模板容器? 为什么要避开普通内存而选择共享内存,那肯定是使用共享内存的优势: l ...
  • billioncloud
  • billioncloud
  • 2016年08月12日 09:36
  • 569
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:循环队列代码(支持对共享内存的操作)
举报原因:
原因补充:

(最多只允许输入30个字)