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

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

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

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

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

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

#include 



// Vector
template
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
class MyList : public MyVector {
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
class MyStack : public MyVector {
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
class MyQueue : public MyVector {
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 vector1(10);
    for (int i = 0; i < 10; i++) {
        vector1.add((char) (65 + i));
    }
    std::cout << "nT = char ：";
    std::cout << vector1;

    //2
    MyVector vector2(10);
    for (int i = 0; i < 10; i++) {
        vector2.add(i);
    }
    std::cout << "nT = int ：";
    std::cout << vector2;

    //3
    MyList 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] << "nn";

    //5
    std::cout << "n测试 MyList：";
    MyList 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< stack(10);
    for (int a = 0; a < 5; a++) {
        stack.add(a + 1024);
    }
    std::cout << "n初始数据："<
        std::cout << "npop()第" << a+1 << "次：" << stack.pop();
    }
    std::cout << "npop()后数据：" << stack;

    //7
    std::cout << "nn测试 MyQueue：";
    MyQueue queue(10);
    for (int i = 0; i < 5; i++) {
        queue.add(1024+i);
    }
    std::cout << "n初始数据："<
        std::cout << "ndequeue()第" << a+1 << "次：" << queue.dequeue();
    }
    std::cout << "ndequeue()后数据：" << queue< 
五. 运行结果