#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;
}