如何实现一个循环队列

原创 2007年09月12日 19:11:00

 下面是一个循环队列的完整实现,欢迎读者朋友参考和指正:

template<typename T  /*元素类型*/ , unsigned int N /*容量*/ >
class CyclicQueue {
public:
    typedef T                    value_type;
    typedef size_t               size_type;
    typedef T&                   reference;
    typedef const T&             const_reference;

    CyclicQueue() : m_popPos(0), m_count(0) {
        assert(N > 0);
        m_beginPtr = (T*)(::operator new(sizeof(T) * N)); // 分配原始空间
        }

    ~CyclicQueue() {
        _Clear();                                 // this->_Clear();
        ::operator delete((void*)m_beginPtr);
        }

    CyclicQueue(const CyclicQueue<T, N>& copy) : m_popPos(0), m_count(0) {
        assert(N > 0);
        m_beginPtr = (T*)(::operator new(sizeof(T) * N));  // 分配原始空间
        size_t copyPos = copy.m_popPos;
        for (size_type idx = 0; idx < copy.m_count; ++idx) {
            _Copy(idx, copy.m_beginPtr[copyPos]);   // this->_Copy();
            ++copyPos; copyPos %= N; ++m_count;
            }
        }

    CyclicQueue& operator=(const CyclicQueue<T, N>& other) {
        if (this != &other) {                  // 检查自赋值
             CyclicQueue<T, N> temp(other);    // 调用拷贝构造函数
             _Swap(temp);                      //  this->_Swap();
            }
        return (*this);
        }

    bool is_empty() const { return (m_count == 0); }
    bool is_full() const { return (m_count == N); }

    value_type front() {
        assert(m_count != 0);
        return (m_beginPtr[m_popPos]);
    }

    value_type front() const {
        assert(m_count != 0);
        return (m_beginPtr[m_popPos]);
    }

    value_type back() {
        return _Back();            // this->_Back();
    }
   
    value_type back() const {
        return _Back();           // this->_Back();
    }
 
   bool push(const_reference data = T()) {
        if (m_count < N) {                 // 不满!
            size_type pushPos = (m_popPos + m_count) % N;
            _Copy(pushPos, data);          // this->_Copy();
            ++m_count;
            return true;
            }
        return false;
    }

    bool pop(reference data) {
        if (m_count > 0) {                    // 不空!
            data = m_beginPtr[m_popPos];      // operator=
            _Destroy(m_popPos);               // this->_Destroy();
            --m_count; ++m_popPos; m_popPos %= N;   // 新的pop位置
            return true;
            }
        return false;
    }

    size_type size() const { return m_count; }
    size_type capacity() const { return N; }
    void clear() { _Clear(); }             // this->_Clear();
    void swap(CyclicQueue<T, N>& other) {
        _Swap(other);                     // this->_Swap();
    }

private:
    void _Clear() {
        for (; m_count > 0; --m_count) {
            _Destroy(m_popPos);           // this->_Destroy();
            ++m_popPos; m_popPos %= N;
            }
        m_popPos = 0;
    }
 
    void _Destroy(size_type idx) {
        assert(idx < N);
        T *pTemp = (m_beginPtr + idx);
        pTemp->~T();                   // 调用析构函数销毁元素对象
    }

    void _Copy(size_type idx, const_reference data) {
        assert(idx < N);
        T *pTemp = (m_beginPtr + idx);
        new ((void*)pTemp) T(data);  // 调用placement new和拷贝构造函数复制对象
    }

    void _Swap(CyclicQueue<T, N>& other) {
        std::swap(m_beginPtr, other.m_beginPtr);
        std::swap(m_popPos, other.m_popPos);
        std::swap(m_count, other.m_count);
    }

    value_type _Back() const {
        assert(m_count != 0);
        size_type pushPos = (m_popPos + m_count) % N;
        if (pushPos == 0)
            return (*(m_beginPtr + N - 1));
        return (m_beginPtr[pushPos - 1]);
    }

    value_type        *m_beginPtr;        // 队列存储空间起始位置
    size_type          m_popPos;          // 下次pop位置
    size_type          m_count;             // 有效元素个数
};

用数组实现一个循环队列

  • 2011年09月16日 11:41
  • 458KB
  • 下载

这里实现一个基于数组的线程安全的循环队列

具体代码如下: #include #include using namespace std; #define QUEUESIZE 128 template class ThreadSafeQue...

使用顺序表实现一个循环队列

用顺序表实现一个循环队列,并实现队列的入列,出列,/** * @filename queue.c * @author haohaibo * @data 2017/4/12 ...

一个文件级循环队列的Journal实现

准备做一个比较靠谱的下载组件,这是第一步,Journal。 最开始想的比较多,希望新增和更新单个消息都尽量少的进行磁盘操作(后来想想,特别是看了Android官方的下载之后,觉得完全没必要,数据库足...

C++实现的一个循环队列

工作之余写的一个简单的循环队列模板类。为什么要用循环duilei

【c++】模拟实现循环队列 三种方法(标识、浪费一个空间、计数器)

什么是循环队列? 为充分利用向量空间,克服”假溢出“现象的方法:将向量空间想象为一个首尾相接的圆环,并称这种向量为循环向量。存储在其中的队列称为循环队列(Circular Queue)。 假象成如图:...

数据结构(C实现)------- 顺序队列(循环队列之少用一个存储空间实现) .

循环顺序队列的另一种实现方式,即少用一个存储空间来实现循环顺序队列

要求顺序循环队不损失一个空间,全部能够得到有效利用,试采用设置标志位tag的方法解决“假溢出”问题,实现顺序循环队列算法

头文件:函数的声明 #include #include #define QUEUESIZE 100 typedef char ElemType; typedef struct { Elem...

循环队列的实现

  • 2014年03月03日 20:38
  • 1.92MB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:如何实现一个循环队列
举报原因:
原因补充:

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