代码仅供参考，完全copy此份实验代码会得0分
基本功能已实现，代码可自由复制、修改、转载。
课程名称： 面向对象技术(C++)
实验项目： 多态性应用
实验仪器： 计算机
一. 实验目的
- 理解面向对象思想中泛型的概念、重要意义；
- 正确声明和使用模板类；
二. 实验内容
- 仿照std::vector, 以模板类的形式实现一个通用的顺序存储容器 MyVector。
- 仿照std:: list, 以模板类的形式实现一个通用的链式存储容器MyList。
- 以模板类的形式实现栈和队列。
三. 基本要求：
- 体现泛型思想、体现继承和派生；
- 要给出关于设计思想的描述或是对设计过程做出必要说明和解释。
- 编写相应的测试用例来验证或者测试所设计类的基本功能及效率。
四. 代码实现
#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;
}
五. 运行结果
