C++实验二：多态性应用

代码仅供参考，完全copy此份实验代码会得0分
基本功能已实现，代码可自由复制、修改、转载。

课程名称： 面向对象技术(C++)
实验项目： 多态性应用
实验仪器： 计算机

一. 实验目的

1. 理解面向对象思想中泛型的概念、重要意义；
2. 正确声明和使用模板类；

二. 实验内容

1. 仿照std::vector, 以模板类的形式实现一个通用的顺序存储容器 MyVector。
2. 仿照std:: list, 以模板类的形式实现一个通用的链式存储容器MyList。
3. 以模板类的形式实现栈和队列。

三. 基本要求：

1. 体现泛型思想、体现继承和派生；
2. 要给出关于设计思想的描述或是对设计过程做出必要说明和解释。
3. 编写相应的测试用例来验证或者测试所设计类的基本功能及效率。

四. 代码实现

#include <iostream>
 
/*
 * 前言：
 *
 * 代码仅供参考，完全copy此份代码得0分后果自负
 *
 * 基本功能已实现，代码可自由复制、修改、转载。
 *
 * 类继承关系：
 *           MyVector
 *           |
 *           |___MyList
 *           |___MyStack
 *           |___MyQueue
 *           |___....
 *
 * */
 
// Vector
template<typename T>
class MyVector {
protected:
    int size;  // 数组实际大小
    int maxCapacity;  // 数组最大容量
    T *data;  // 数据指针
public:
    // 无参构造函数，初始容量大小为10
    MyVector() {
        maxCapacity = 10;
        data = new T[maxCapacity];
        size = 0;
    }
 
    // 有参构造：定义初始大小
    MyVector(int maxCapacity) {
        this->maxCapacity = maxCapacity;
        data = new T[this->maxCapacity];
        size = 0;
    }
 
    // 拷贝构造，注意：泛型T相同时才不报错
    MyVector(MyVector &vector) {
        *this = std::move(vector);
    }
 
    // 析构函数：最后执行，释放内存。
    ~MyVector() {
        if (data != nullptr) {
            delete[] data;
            data = nullptr;
        }
    }
 
    // 重载操作符：[]
    T operator[](int num) {
        return data[num];
    }
 
    // 获取数组实际大小
    int length() const {
        return size;
    }
 
    // 模拟 add() 方法
    void add(T data) {
        this->data[this->size] = data;
        this->size++;
    }
 
    // 重载操作符：<<（输出）
    friend std::ostream &operator<<(std::ostream &ostream, const MyVector &vector) {
        for (int a = 0; a < vector.length(); a++) {
            ostream << " " << vector.data[a];
        }
        return ostream;
    }
};
 
// MyList
template<typename T>
class MyList : public MyVector<T> {
public:
 
    // 无参构造
    MyList() {
        this->size = 0;
        this->data = new T[this->maxCapacity];
        this->maxCapacity = 10;
    }
 
    // 有参构造：定义初始大小
    MyList(int capacity) {
        this->maxCapacity = capacity;
        this->data = new T[this->maxCapacity];
        this->size = 0;
    }
 
    // 拷贝构造，注意：泛型T相同时才不报错
    MyList(MyList &list) {
        *this = std::move(list);
    }
 
    // 析构函数：最后执行，释放内存。
    ~MyList() {
        if (this->data != nullptr) {
            delete[] this->data;
            this->data = nullptr;
        }
    }
 
    // 模拟 List类的 get() 方法。
    T get(int i) const {
        return this->data[i];
    }
};
 
// MyStack：先进后出
template<typename T>
class MyStack : public MyVector<T> {
public:
 
    // 无参构造
    MyStack(void) {
        this->maxCapacity = 10;
        this->data = new T[this->maxCapacity];
        this->size = 0;
    }
 
    // 有参构造：定义初始大小
    MyStack(int capacity) {
        this->data = new T[this->maxCapacity];
        this->maxCapacity = capacity;
        this->size = 0;
    }
 
    // 拷贝构造，注意：泛型T相同时才不报错
    MyStack(MyStack &stack) {
        *this = std::move(stack);
    }
 
    // 析构函数：最后执行，释放内存。
    ~MyStack(void) {
        if (this->data != nullptr) {
            delete[] this->data;
            this->data = nullptr;
        }
    }
 
    // pop()： 先进后出
    T pop() {
        T data = this->data[(this->size)-- - 1];
        return data;
    }
};
 
// MyQueue队列：先进先出
template<typename T>
class MyQueue : public MyVector<T> {
public:
    int head = 0;
public:
    // 无参构造
    MyQueue() {
        this->maxCapacity = 10;
        this->data = new T[this->maxCapacity];
        this->size = 0;
    }
 
    // 有参构造：定义初始大小
    MyQueue(int capacity) {
        this->maxCapacity = capacity;
        this->data = new T[this->maxCapacity];
        this->size = 0;
    }
 
    // 拷贝构造，注意：泛型T相同时才不报错
    MyQueue(MyQueue &queue) {
        *this = std::move(queue);
    }
 
    // 析构函数：最后执行，释放内存。
    ~MyQueue(void) {
        if (this->data != nullptr) {
            delete[] this->data;
            this->data = nullptr;
        }
    }
 
    T dequeue() {
        if (head < this->size - 1) {
            T data = this->data[head];
            head++;
            return data;
        }
    }
 
    friend std::ostream &operator<<(std::ostream &ostream, const MyQueue &queue) {
        for (int a = queue.head; a < queue.length(); a++) {
            ostream << " " << queue.data[a];
        }
        return ostream;
    }
};
 
 
// 主方法
int main() {
 
    //1
    std::cout << "\n测试 MyVector：";
    MyVector<char> vector1(10);
    for (int i = 0; i < 10; i++) {
        vector1.add((char) (65 + i));
    }
    std::cout << "\nT = char ：";
    std::cout << vector1;
 
    //2
    MyVector<int> vector2(10);
    for (int i = 0; i < 10; i++) {
        vector2.add(i);
    }
    std::cout << "\nT = int ：";
    std::cout << vector2;
 
    //3
    MyList<std::string> vector3(1100);
    for (int i = 0; i < 10; i++) {
        vector3.add("C--");
    }
    std::cout << "\nT = string ：";
    std::cout << vector3;
 
    //4
    std::cout << "\n测试重载操作符[]：" << vector1[5] << "\n\n";
 
    //5
    std::cout << "\n测试 MyList：";
    MyList<int> list(10);
    for (int a = 0; a < 5; a++) {
        list.add(a + 1024);
    }
    for (int a = 0; a < 5; a++) {
        std::cout << "\nget(" << a << ")=" << list.get(a);
    }
    std::cout<<std::endl;
 
    //6
    std::cout << "\n\n测试 MyStack：";
    MyStack<int> stack(10);
    for (int a = 0; a < 5; a++) {
        stack.add(a + 1024);
    }
    std::cout << "\n初始数据："<<stack;
    for (int a = 0; a < 3; a++) {
        std::cout << "\npop()第" << a+1 << "次：" << stack.pop();
    }
    std::cout << "\npop()后数据：" << stack;
 
    //7
    std::cout << "\n\n测试 MyQueue：";
    MyQueue<int> queue(10);
    for (int i = 0; i < 5; i++) {
        queue.add(1024+i);
    }
    std::cout << "\n初始数据："<<queue;
    for (int a = 0; a < 3; a++) {
        std::cout << "\ndequeue()第" << a+1 << "次：" << queue.dequeue();
    }
    std::cout << "\ndequeue()后数据：" << queue<<std::endl;
    return 0;
}
 
 

五. 运行结果