继承和多态 My_queue

main.cpp

#include "My_queue.h"

int main() {
    My_queue queue;

       // push() 和 size()
       cout << "开始测试队列插入(push)功能:" << endl;
       queue.push(10);
       queue.push(20);
       queue.push(30);
       cout << "队列大小: " << queue.size() << endl;
       cout << "队列头元素: " << queue.front() << endl;
       cout << "队列尾元素: " << queue.back() << endl;

       //pop()
       cout << "\n测试删除元素(pop)功能:" << endl;
       queue.pop(); // 删除第一个元素
       cout << "删除第一个元素后，队列头元素: " << queue.front() << endl;
       cout << "队列大小: " << queue.size() << endl;

       //front() 和 back()
       cout << "\n测试 front() 和 back():" << endl;
       cout << "队列头元素: " << queue.front() << endl;
       cout << "队列尾元素: " << queue.back() << endl;

       //空队列
       cout << "\n测试队列是否为空(empty):" << endl;
       queue.pop(); // 删除第一个元素
       queue.pop(); // 删除第二个元素
       cout << "此时队列是否为空: " << (queue.empty() ? "是" : "否") << endl;

       //赋值操作符
       cout << "\n测试赋值操作符(operator=):" << endl;
       My_queue anotherQueue;
       anotherQueue.push(100);
       anotherQueue.push(200);
       cout << "另一个队列头元素: " << anotherQueue.front() << endl;
       anotherQueue = queue; // 将空队列赋值给 anotherQueue
       cout << "赋值后，另一个队列是否为空: " << (anotherQueue.empty() ? "是" : "否") << endl;

       // 再次插入新元素到 queue
       cout << "\n再次测试插入(push)功能:" << endl;
       queue.push(40);
       queue.push(50);
       cout << "新插入后队列大小: " << queue.size() << endl;
       cout << "队列头元素: " << queue.front() << endl;
       cout << "队列尾元素: " << queue.back() << endl;

       //swap()
       cout << "\n测试队列交换(swap):" << endl;
       My_queue queue2;
       queue2.push(999);
       queue2.push(888);
       cout << "交换前队列 queue 的头元素: " << queue.front() << endl;
       cout << "交换前队列 queue2 的头元素: " << queue2.front() << endl;

       queue.swap_t(queue2); // 交换 queue 和 queue2 的内容
       cout << "交换后队列 queue 的头元素: " << queue.front() << endl;
       cout << "交换后队列 queue2 的头元素: " << queue2.front() << endl;
    return 0;
}

My_queue.h

#ifndef MY_QUEUE_H
#define MY_QUEUE_H
#include <iostream>
using namespace std;  // 添加这一行以使用标准命名空间

class My_queue {
private:
    int* ptr;           // 存储队列元素的动态数组
    int front_index;          // 队列头部索引
    int back_index;           // 队列尾部索引
    int queueSize;      // 当前队列大小
    int queueMax;       // 当前队列最大容量

    void resize();      // 动态调整容量

public:
    My_queue();                           // 构造函数
    ~My_queue();                          // 析构函数
    My_queue& operator=(const My_queue& other); // 赋值操作符
    int front();                   // 访问第一个元素
    int back();                    // 访问最后一个元素
    bool empty() const;                   // 检查队列是否为空
    int size() const;                     // 返回元素数
    void push(int value);                 // 向队列尾部插入元素
    void pop();                           // 删除首个元素
    void swap_t(My_queue& other);           // 交换内容
};

#endif // MY_QUEUE_H

My_queue.cpp

#include "My_queue.h"


// 构造函数
My_queue::My_queue() : front_index(0), back_index(0), queueSize(0), queueMax(2) {
    ptr = new int[queueMax]; // 初始容量为2
}

// 析构函数
My_queue::~My_queue() {
    delete[] ptr; // 释放动态数组
}

// 赋值操作符
My_queue& My_queue::operator=(const My_queue& other) {
    if (this != &other) {
        // 先释放现有数据
        delete[] ptr;

        // 复制数据
        front_index = other.front_index;
        back_index = other.back_index;
        queueSize = other.queueSize;
        queueMax = other.queueMax;
        ptr = new int[queueMax]; // 在堆上申请新内存

        for (int i = 0; i < queueSize; ++i) {
            ptr[i] = other.ptr[(front_index + i) % queueMax]; // 处理环形队列
        }
    }
    return *this;
}

// 访问第一个元素
int My_queue::front() {
    if (empty()) {
        cout<< "队列为空" <<endl;
        return -1;
    }
    return ptr[front_index];
}

// 访问最后一个元素
int My_queue::back() {
    if (empty()) {
        cout<< "队列为空" <<endl;
        return -1;
    }
    return ptr[back_index+1];
}

// 检查队列是否为空
bool My_queue::empty() const {
    return queueSize == 0;
}

// 返回元素数
int My_queue::size() const {
    return queueSize;
}

// 向队列尾部插入元素
void My_queue::push(int value) {
    if (queueSize >= queueMax) {
        resize();
    }
    ptr[back_index] = value;
    back_index = (back_index + 1) % queueMax; // 循环队列
    queueSize++;
}

// 动态调整容量
void My_queue::resize() {
    int newQueueMax = queueMax * 2;
    int* newData = new int[newQueueMax];

    // 复制旧数据到新数组
    for (int i = 0; i < queueSize; ++i) {
        newData[i] = ptr[(front_index + i) % queueMax];
    }

    delete[] ptr;
    ptr = newData; // 更新指针
    front_index = 0;
    back_index = queueSize;
}

// 删除首个元素
void My_queue::pop() {
    if (empty()) {
        cout<< "队列为空" <<endl;
        return;
    }
    front_index = (front_index + 1) % queueMax; // 循环队列
    queueSize--;
}

// 交换内容
void My_queue::swap_t(My_queue& other) {
    swap(front_index, other.front_index);
    swap(back_index, other.back_index);
    swap(queueSize, other.queueSize);
    swap(queueMax, other.queueMax);
    swap(ptr, other.ptr);
}