C ++创建固定大小的队列

时间:2019-05-28 03:07:28

标签: c++ queue

C ++ 中,如何创建简单的固定大小队列

我已经在Java和Python中多次这样做,但是我正在寻找一种基于C ++的方式。

我需要一个只有2个元素的简单FIFO队列,才能使用pushpop实用程序:我已经意识到我可以实现自己的类来执行这种操作限制,但我的答案旨在了解是否已经有解决方案。

或者可能通过数组完成相同的任务?那也行得通。

非常感谢您。

3 个答案:

答案 0 :(得分:1)

在C ++中,如何创建简单的固定大小队列

首先,我认为您真正想要的是固定容量队列,即队列的大小本身将受限于队列的容量,但是大小可能会有所不同。例如,如果队列为空,则大小最初可以为零,并在将元素插入队列时增加到队列的容量。


使用boost::circular_buffer

Boost库具有实现boost::circular_buffer容器(boost/circular_buffer.hpp)的库Boost.CircularBuffer。此容器适合用作固定容量的FIFO。

std::vector不同,boost::circular_buffer容量保持不变,无论您将多少元素插入到容器中。也就是说,幕后不会发生重新分配:如果boost::circular_buffer size 达到其容量,那么插入新元素只会覆盖现有元素。 / p>

您可以指定boost::circular_buffer的建设能力:

boost::circular_buffer<int> cb(2);

cb的容量为 2 ,并且初始大小为零,因为容器为空。它的大小不能超过其容量。但是,您可以明确地更改容器的容量,例如,通过调用circular_buffer::set_capacity()

通过使用push_back()pop_front()成员函数,您可以将boost::circular_buffer用作FIFO。示例:

#include <boost/circular_buffer.hpp>
#include <iostream>

void print(const boost::circular_buffer<int>& cb) {
   std::cout << "size: " << cb.size() << ", capacity: " << cb.capacity() << '\n';

   for (auto const& elem: cb)
      std::cout << elem << ' ';
   std::cout << '\n';
}

auto main() -> int {
   // empty: size is zero
   boost::circular_buffer<int> cb(3);
   print(q);

   cb.push_back(0);
   print(cb);

   cb.push_back(1);
   print(cb);

   cb.push_back(2);  
   print(cb);

   // overwrites the oldest element: 0
   cb.push_back(3);
   print(cb);

   // overwrites the oldest element: 1
   cb.push_back(4);
   print(cb);

   cb.pop_front();
   print(cb);

   cb.pop_front();
   print(cb);

   // empty again
   cb.pop_front();
   print(cb);
}

输出:

size: 0, capacity: 3

size: 1, capacity: 3
0
size: 2, capacity: 3
0 1
size: 3, capacity: 3
0 1 2
size: 3, capacity: 3
1 2 3
size: 3, capacity: 3
2 3 4
size: 2, capacity: 3
3 4
size: 1, capacity: 3
4
size: 0, capacity: 3

std::queueboost::circular_buffer一起使用

std::queue是一个容器适配器,其基础容器默认为std::deque。但是,您可以将boost::circular_buffer用作std::queue的基础容器,因为它实现了front()back()push_back()pop_front()成员函数:

#include <queue>
#include <boost/circular_buffer.hpp>
#include <cassert>

template<typename T>
using FixedCapacityQueue = std::queue<T, boost::circular_buffer<T>>;

auto main() -> int {
   FixedCapacityQueue<int> fixedCapQueue(boost::circular_buffer<int>(3));

   fixedCapQueue.push(0);
   fixedCapQueue.push(1);
   fixedCapQueue.push(2);
   fixedCapQueue.push(3); // overwrites the 0
   assert(fixedCapQueue.front() == 1);

   fixedCapQueue.pop(); // pops the 1
   assert(fixedCapQueue.front() == 2); 
}

答案 1 :(得分:0)

您可以从队列继承,然后重新实现push方法。这是一个基本示例。

#include <queue>
#include <deque>
#include <iostream>

template <typename T, int MaxLen, typename Container=std::deque<T>>
class FixedQueue : public std::queue<T, Container> {
public:
    void push(const T& value) {
        if (this->size() == MaxLen) {
           this->c.pop_front();
        }
        std::queue<T, Container>::push(value);
    }
};

int main() {
    FixedQueue<int, 3> q;
    q.push(1);
    q.push(2);
    q.push(3);
    q.push(4);
    q.push(5);
    q.push(6);
    q.push(7);

    while (q.size() > 0)
    {
        std::cout << q.front() << std::endl;
        q.pop();
    }
}

这将打印

$ g++ fixedqueue.cpp -std=c++17 -o fixedqueue && ./fixedqueue
5
6
7

答案 2 :(得分:0)

使用循环自定义容器。在线示例如下:https://ideone.com/HZytWn

#include <array>
#include <iostream>
#include <queue>

template <typename T, size_t N = 2>
class CyclicArray {
 public:
  typedef typename std::array<T, N>::value_type value_type;
  typedef typename std::array<T, N>::reference reference;
  typedef typename std::array<T, N>::const_reference const_reference;
  typedef typename std::array<T, N>::size_type size_type;

  void push_back(const T& v) {
    if (size_ + 1 == N)
      throw;
    ++size_;
    array_[(front_ + size_) % N] = v;
  }

  void pop_front() {
    if (size_ < 1)
      throw;
    ++front_;
    --size_;
    if (front_ >= N)
      front_ = 0;
  }

  reference front() {
    return array_[front_];
  }

  size_type size() const {
    return size_;
  }

 private:
  size_type front_ = 0;
  size_type size_ = 0;
  std::array<T, N> array_;
};

int main() {
    std::queue<int, CyclicArray<int, 2>> queue;
    queue.push(1);
    int f = queue.front();
    queue.pop();
    return 0;
}