嵌套使用模板类

#include<iostream>
using namespace std;

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() {
		delete[] items;
		items = nullptr;
	}
	bool isempty()const {
		if (top == 0)return true;
		return false;
	}
	bool isfull()const {
		if (top == stacksize)return true;
		return false;
	}
	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;
	}
};
template <class T>
class Vector
{
private:
	int len;
	T* items;
public:
	Vector(int size=2) :len(size) {
		items = new T[len];
	}
	~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];
		}
		delete[] items;
		items = temp;
		len = size;
	}
	int getlen()const { 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() {
	//Vector容器的大小缺省值是2，Stack容器的缺省值是3.
	//创建Vector容器，容器中的元素用Stack
	Vector<Stack<string>> vs;
	//手工的往容器中插入数据
	vs[0].push("zhongge1"); vs[0].push("zhongge2"); vs[0].push("zhongge3");
	vs[1].push("zhongge1"); vs[1].push("zhongge2"); vs[1].push("zhongge3");
	//用嵌套的循环，把容器中的数据显示出来
	for (int ii = 0; ii < vs.getlen(); ii++) {

		while (vs[ii].isempty() == false) {
			string item;
			vs[ii].pop(item);
			cout << "item = " << item << endl;
		}
	}
	return 0;
}

item = zhongge3
item = zhongge2
item = zhongge1
item = zhongge3
item = zhongge2
item = zhongge1

C:\Users\代伟业\Desktop\C++\初始化列表\project\x64\Debug\project.exe (进程 6216)已退出，代码为 0。
按任意键关闭此窗口. . .

 容器中的容器就是二维的容器。

再往Vector容器中加多两个元素。

vs[2].push("ouge1"); vs[2].push("ouge2");

出现内存错误：在扩展数组内存空间的这个函数中:

void resize(int size) {
    if (size <= len)return;
    T* temp = new T[size];
    for (int i = 0; i < len; i++) {
        temp[i] = items[i];
    }
    delete[] items;
    items = temp;
    len = size;
}

这句： temp[i] = items[i];是把原数组中的元素复制到新数组，若复制的是cpp内置的数据类型，不存在任何问题，如果复制的是类，而且类使用了堆区内存，就存在浅拷贝的问题。

Stack类用了堆区内存，所以说对于Stack用浅拷贝是不行的，得用深拷贝，所以Stack这种类一定要重写拷贝构造函数和赋值函数。在这个demo中没用到Stack的拷贝构造函数那就不管他了，但是应该为Stack类重写赋值函数，实现深拷贝。

Stack& operator=(const Stack& v) {
	delete[] items;
	stacksize = v.stacksize;
	items = new Datatype[stacksize];
	for (int i = 0; iMstacksize; i++)items[i] = v.items[i];
	top = v.top;
	return *this;
}

———————————————————————————————————————

Vector& operator=(const Vector& v) {
	delete[] items;
	len = v.len;
	items = new T[len];
	for (int i = 0; i < len; i++)items[i] = item[i];
	return *this;
}

给Vector类也加上赋值运算符的重载函数，实现深拷贝，等一会用到；

——————————————————————————————

now创建一个Stack容器，容器中的元素用Vector。也就是说，栈中的每个元素是一个数组。

#include<iostream>
using namespace std;

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() {
		delete[] items;
		items = nullptr;
	}
	Stack& operator=(const Stack& v) {
		delete[] items;
		stacksize = v.stacksize;
		items = new Datatype[stacksize];
		for (int i = 0; stacksize; i++)items[i] = v.items[i];
		top = v.top;
		return *this;
	}
	bool isempty()const {
		if (top == 0)return true;
		return false;
	}
	bool isfull()const {
		if (top == stacksize)return true;
		return false;
	}
	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;
	}
};
template <class T>
class Vector
{
private:
	int len;
	T* items;
public:
	Vector(int size=2) :len(size) {
		items = new T[len];
	}
	~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];
		}
		delete[] items;
		items = temp;
		len = size;
	}
	int getlen()const { return len; }
	Vector& operator=(const Vector& v) {
		delete[] items;
		len = v.len;
		items = new T[len];
		for (int i = 0; i < len; i++)items[i] =v.items[i];
		return *this;
	}
	T& operator[](int ii) {
		if (ii > len)resize(ii + 1);
		return items[ii];
	}
	const T& operator[](int ii)const { return items[ii]; }

};
int main() {
	
	//创建一个Stack容器，容器中的元素用Vector
	Stack<Vector<string>> sv;
	//创建一个临时的Vector<string>容器;
	Vector<string> tmp;
	//第一个入栈的元素
	tmp[0] = "sb1"; tmp[1] = "sb2"; sv.push(tmp);
	//第二个入栈的元素
	tmp[0] = "sb1"; tmp[1] = "sb2"; sv.push(tmp);
	//第三个入栈的元素(数组容器中有四个元素)
	tmp[0] = "sb1"; tmp[1] = "sb2"; tmp[2] = "sb1"; tmp[3] = "sb2"; sv.push(tmp);
	//用嵌套的循环，把容器中的数据显示出来
	while (sv.isempty() == false) {
		sv.pop(tmp);
		for (int i = 0; i < tmp.getlen(); i++) {
			cout << "vs[" << i << "] = " << tmp[i] << endl;
		}
	}
	return 0;
}