fork download
copy 
  1. #include <iostream>
  2. #include <stdexcept>
  3. #include <string>
  4.  
  5. template <typename T>
  6. class CircularQueue {
  7. private:
  8.     T* data;
  9.     std::size_t capacity;
  10.     std::size_t frontIndex;
  11.     std::size_t rearIndex;
  12.     std::size_t count;
  13.  
  14. public:
  15.     explicit CircularQueue(std::size_t capacity)
  16.         : data(nullptr),
  17.           capacity(capacity),
  18.           frontIndex(0),
  19.           rearIndex(0),
  20.           count(0) {
  21.  
  22.         if (capacity == 0) {
  23.             throw std::invalid_argument("Capacity must be greater than 0");
  24.         }
  25.  
  26.         data = new T[capacity];
  27.     }
  28.  
  29.     ~CircularQueue() {
  30.         delete[] data;
  31.     }
  32.  
  33.     CircularQueue(const CircularQueue&) = delete;
  34.     CircularQueue& operator=(const CircularQueue&) = delete;
  35.  
  36.     bool isEmpty() const noexcept {
  37.         return count == 0;
  38.     }
  39.  
  40.     bool isFull() const noexcept {
  41.         return count == capacity;
  42.     }
  43.  
  44.     std::size_t size() const noexcept {
  45.         return count;
  46.     }
  47.  
  48.     std::size_t maxSize() const noexcept {
  49.         return capacity;
  50.     }
  51.  
  52.     void enqueue(const T& value) {
  53.         if (isFull()) {
  54.             throw std::overflow_error("Queue is full");
  55.         }
  56.  
  57.         data[rearIndex] = value;
  58.         rearIndex = (rearIndex + 1) % capacity;
  59.         ++count;
  60.     }
  61.  
  62.     void dequeue() {
  63.         if (isEmpty()) {
  64.             throw std::underflow_error("Queue is empty");
  65.         }
  66.  
  67.         frontIndex = (frontIndex + 1) % capacity;
  68.         --count;
  69.     }
  70.  
  71.     T& front() {
  72.         if (isEmpty()) {
  73.             throw std::underflow_error("Queue is empty");
  74.         }
  75.  
  76.         return data[frontIndex];
  77.     }
  78.  
  79.     const T& front() const {
  80.         if (isEmpty()) {
  81.             throw std::underflow_error("Queue is empty");
  82.         }
  83.  
  84.         return data[frontIndex];
  85.     }
  86.  
  87.     T& back() {
  88.         if (isEmpty()) {
  89.             throw std::underflow_error("Queue is empty");
  90.         }
  91.  
  92.         std::size_t index =
  93.             (rearIndex + capacity - 1) % capacity;
  94.  
  95.         return data[index];
  96.     }
  97.  
  98.     const T& back() const {
  99.         if (isEmpty()) {
  100.             throw std::underflow_error("Queue is empty");
  101.         }
  102.  
  103.         std::size_t index =
  104.             (rearIndex + capacity - 1) % capacity;
  105.  
  106.         return data[index];
  107.     }
  108.  
  109.     void clear() noexcept {
  110.         frontIndex = 0;
  111.         rearIndex = 0;
  112.         count = 0;
  113.     }
  114.  
  115.     void print() const {
  116.         if (isEmpty()) {
  117.             std::cout << "Queue: empty\n";
  118.             return;
  119.         }
  120.  
  121.         std::cout << "Queue: ";
  122.  
  123.         for (std::size_t i = 0; i < count; ++i) {
  124.             std::size_t index =
  125.                 (frontIndex + i) % capacity;
  126.  
  127.             std::cout << data[index];
  128.  
  129.             if (i + 1 < count) {
  130.                 std::cout << " ";
  131.             }
  132.         }
  133.  
  134.         std::cout << '\n';
  135.     }
  136. };
  137.  
  138. int main() {
  139.     try {
  140.         CircularQueue<int> queue(5);
  141.  
  142.         // Добавление элементов
  143.         queue.enqueue(10);
  144.         queue.enqueue(20);
  145.         queue.enqueue(30);
  146.  
  147.         queue.print();
  148.  
  149.         // Первый элемент
  150.         std::cout << "Front: " << queue.front() << '\n';
  151.  
  152.         // Последний элемент
  153.         std::cout << "Back: " << queue.back() << '\n';
  154.  
  155.         // Удаление элементов
  156.         queue.dequeue();
  157.         queue.dequeue();
  158.  
  159.         queue.print();
  160.  
  161.         // Проверка циклического использования массива
  162.         queue.enqueue(40);
  163.         queue.enqueue(50);
  164.         queue.enqueue(60);
  165.  
  166.         queue.print();
  167.  
  168.         // Размер и состояние
  169.         std::cout << "Size: " << queue.size() << '\n';
  170.         std::cout << "Capacity: " << queue.maxSize() << '\n';
  171.         std::cout << "Empty: "
  172.                   << (queue.isEmpty() ? "yes" : "no") << '\n';
  173.         std::cout << "Full: "
  174.                   << (queue.isFull() ? "yes" : "no") << '\n';
  175.  
  176.         // Проверка исключения при переполнении
  177.         queue.enqueue(70);
  178.  
  179.         // Очистка очереди
  180.         queue.clear();
  181.  
  182.         std::cout << "After clear:\n";
  183.         queue.print();
  184.  
  185.     } catch (const std::exception& error) {
  186.         std::cerr << "Error: " << error.what() << '\n';
  187.         return 1;
  188.     }
  189.  
  190.     return 0;
  191. }
Success #stdin #stdout 0s 5320KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
Queue: 10 20 30
Front: 10
Back: 30
Queue: 30
Queue: 30 40 50 60
Size: 4
Capacity: 5
Empty: no
Full: no
After clear:
Queue: empty
https://ideone.com/Z9AhAl
language:
C++14 (gcc 8.3)
created:
9 hours ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!