数组实现循环队列

.h

#pragma once
#include "operate_array.h"

class operate_queue
{
public:
    operate_queue(int capacity, int value);
    ~operate_queue();

    void in_queue(int element);
    int out_queue();
    void out_put();

private:
    operate_array *m_pArray;
    int m_iHead;
    int m_iTail;
};

.cpp

#include "pch.h"
#include "operate_queue.h"


operate_queue::operate_queue(int capacity, int value)
{
    m_iHead = 0;
    m_iTail = 0;
    m_pArray = new operate_array(capacity, value);
}


operate_queue::~operate_queue()
{
}

void operate_queue::in_queue(int element)
{
    if ((m_iTail + 1) % m_pArray->capacity() == m_iHead)
    {
        std::cout << "queue is full" << std::endl;
        return;
    }
    m_pArray->change_element(element, m_iTail);
    m_iTail = (m_iTail + 1) % m_pArray->capacity();
}

int operate_queue::out_queue()
{
    if (m_iTail == m_iHead)
    {
        std::cout << "queue is null" << std::endl;
        return -1;
    }
    int element = m_pArray->get_element(m_iHead);
    m_pArray->change_element(m_iHead, 0);
    m_iHead = (m_iHead + 1) % m_pArray->capacity();
    return element;
}

void operate_queue::out_put()
{
    for (int i = m_iHead; i != m_iTail; i = (i + 1) % m_pArray->capacity())
    {
        std::cout << "m_pArray[" << i <<"]:" << m_pArray->get_head()[i] << std::endl;
    }
}

 

测试

#include "pch.h"
#include <iostream>
#include "operate_queue.h"

int main()
{
    operate_queue obj_queue(6, 0);
    obj_queue.in_queue(3);
    obj_queue.in_queue(7);
    obj_queue.in_queue(4);
    obj_queue.in_queue(1);
    obj_queue.in_queue(5);
    obj_queue.in_queue(11);
    obj_queue.in_queue(12);
    obj_queue.out_put();
    //int i = obj_queue.out_queue();
    //int j = obj_queue.out_queue();
    //int m = obj_queue.out_queue();
    int n = obj_queue.out_queue();
    int k = obj_queue.out_queue();
    int l = obj_queue.out_queue();
    obj_queue.out_put();
    obj_queue.in_queue(22);
    obj_queue.in_queue(23);
    obj_queue.out_put();
}

测试结果