模板类实现数组，可变数组,栈,嵌套使用

template <class DataType>
class Stack {//栈类
private :
	DataType* items;//栈数组
	int stacksize;//栈大小
	int top;//栈顶指针
public:
	//1构造函数分配栈数组的大小 2栈顶指针初始化为0
	Stack(int size=3):stacksize(size),top(0) {
		items=new DataType[stacksize];
	}
	//重写赋值运算 实现深拷贝
	Stack& operator =(const Stack& v) {
		delete []items;//释放原来内存
		stacksize= v.stacksize;//实际栈的大小
		items = new DataType[stacksize];//重新分配数组
		for (int i = 0; i < stacksize; i++) {
			items[i] = v.items[i];
		}
		top = v.top;
		return *this;
	}


	~Stack() {
		delete []items;
		items = nullptr;
	}
	//判断栈是否为空
	bool isEmpty()const {
		return top == 0;
	}
	//判断栈是否为满
	bool isFull()const {
		return top == stacksize;
	}

	//元素入栈
	bool push(const DataType& item) {
		if (top < stacksize) {//栈顶指针小于栈大小可以入栈
			items[top++] = item;
			return true;
		}
		return false;
	}
	//元素出栈
	bool pop(DataType& item) {
		if (top > 0) {
			item = items[--top];
			return true;
		}
		return false;
	}

};
/*
int main() {
	Stack<string>  ss=Stack<string>(5);
	ss.push("tom");
	ss.push("jack");
	ss.push("mary");
	ss.push("smith");
	ss.push("likuo");
	元素的出栈
	string item;
	while (ss.isEmpty() == false) {
		ss.pop(item);
		cout << "出栈 item= " << item << endl;
	}
}
*/

模拟数组容器
#include<string.h>
template <class T,int len=10>
class Array {
private:
	//数组元素
	T items[len];
public:
	Array() {
	}
	~Array() {}
	//重载操作符[] 可以修改数组元素
	T& operator[](int ii) {
		return items[ii];
	}

	//重载操作符[] 不可以修改数组元素
	const T& operator[](int ii) const{
		return items[ii];
	}
};
//变长数组
template <class T>
class Vector {
private:
	int len;//数组元素大小
	//数组元素
	T* items;
public:
	Vector(int size=2) :len(size){//创建一个大小为size的数组
		items = new T[len];
	}

	//重写赋值运算 实现深拷贝
	Vector& operator =(const Vector& v) {
		delete[]items;//释放原来内存
		len = v.len;//实际Vector的大小
		items = new T[len];//重新分配数组
		for (int i = 0; i < len; i++) {
			items[i] = v.items[i];
		}
		
		return *this;
	}
	~Vector() {
		delete[]items;
		items = nullptr;
	}

	//扩展数组的大小
	void resize(int size){
		if (size <= len)return;//小于等于该数组大小就返回不扩展
		T* temp = new T[size];
		//把之前数组的内容拷贝到这个数组
		for (int i = 0; i < len; i++) {
			temp[i] = items[i];
		}
		//销毁items
		delete[]items;
		items = temp;//让新数组指向旧数组
		len = size;//数组成员变量的值也要变化
	}

	//获得数组长度
	int size() {
		return len;
	}
	//

	//重载操作符[] 可以修改数组元素
	T& operator[](int ii) {
		if (ii >= len) {//	数组长度小于获取元素的下标志扩展数组
			resize(ii + 1);
		}
		return items[ii];
	}

	//重载操作符[] 不可以修改数组元素
	const T& operator[](int ii) const {
		return items[ii];
	}
};
 int main(){
	 //Array<string> arr = Array<string>();
	 Vector<int> arr(1);
	 //for (int i = 0; i < 5; i++) {
		// arr[i] = "zhansan";
		// cout << "arr["<<i<<"] = " << arr[i] << endl;
	 //}
	 //Vector默认2 Stack默认3
	 //Vector<Stack<string>> vs;
	 //vs[0].push("zhangsan1");
	 //vs[0].push("zhangsan2"); 
	 //vs[0].push("zhangsan3");
	 //vs[1].push("李四1");
	 //vs[1].push("李四2");
	 //vs[1].push("李四3");
	 //vs[2].push("sdasdas");


	 //for (int i = 0; i < vs.size(); i++) {
		// //循环输出栈里面的内容
		// while (vs[i].isEmpty() == false) {
		//	 string item;
		//	 vs[i].pop(item);
		//	 cout << "item=  " << item << endl;
		// }
	 //}


	 //创建一个Stack容器 里面中的元素用Vector<string>
	 Stack < Vector<string> >sv;
	 Vector<string> temp;
	 temp[0] = "西施", temp[1] = "西瓜";
	 sv.push(temp);
	 temp[0] = "西施1", temp[1] = "西瓜1"; 
	 sv.push(temp);
	 temp[0] = "西施2", temp[1] = "西瓜1",temp[2]="黄瓜",temp[3]="木瓜"; 
	 sv.push(temp);
	 while (sv.isEmpty() == false) {
		 Vector<string> vr;
		 sv.pop(vr);
		 for (int i = 0; i < vr.size(); i++) {
			 cout << "vr[" << i << "] = " << vr[i] << endl;
		 }
	 }

 }