C++类模板——嵌套使用
目录
类模板的嵌套分类
一、数组的成员是栈
（一）Vector大小为2，Stack大小为3；不对Vector进行扩展；（浅拷贝），只对C++内置数据类型进行拷贝
1）代码
2）注意事项
3）结果
（二）Vector大小为2，Stack大小为3；对Vector进行扩展；（深拷贝），对类的拷贝且类用到了堆区需要重写拷贝函数
1）代码
2）注意事项
3）结果
二、栈的成员是数组（入栈时需要拷贝数组，要写Vector的拷贝构造函数）
1）代码
2）注意事项
3）结果
三、数组的成员是数组 （数组赋值时需要用到数组的拷贝构造函数）
1）代码
2）注意事项
3）结果
类模板的嵌套分类
一、数组的成员是栈
二、栈的成员是数组
三、数组的成员是数组
默认Vector大小为2，Stack大小为3；
一、数组的成员是栈
栈没有自动扩展功能，数组有自动扩展功能
（一）Vector大小为2，Stack大小为3；不对Vector进行扩展；（浅拷贝），只对C++内置数据类型进行拷贝
Stack的数据类型是C++内置的数据类型时，没有扩展Vector也没有用到Vector的resize（）Stack的拷贝构造函数
使用浅拷贝，不需要重写Stack的拷贝构造函数
1）代码
#include
#include
using namespace std;
//栈类
template //在类声明前加上模板的头部标签
class Stack
{
private: //3个成员变量
DataType *items; //栈数组，栈的元素用整数数组存放，动态分配一块数组空间
int stacksize; //栈大小，栈的大小用成员变量表示
int top; //栈顶指针，栈顶指针用整数表示，不是C++的指针
public: //成员函数
//构造函数：1）分配栈数组空间；2）把栈顶指针初始化为0
Stack(int size=3):stacksize(size),top(0) //需要一个参数（栈的大小），采用初始化列表对成员赋值
{
items=new DataType [stacksize]; //在构造函数中，给栈数组分配内存
}
~Stack() //析构函数，释放数组空间
{
delete []items; //释放数组空间
items=NULL; //指针置为空
}
bool isempty()const{ //判断栈是否为空
return top==0;
}
bool isfull()const{ //判断栈是否为满
return top==stacksize;
}
bool push(const DataType& item){ //元素入栈
if(top0)
{
item=items[--top];
return true;
}
return false;
}
};
//数组容器类
template
class Vector
{
private:
int len; //数组大小用成员变量表示
T *items; //数组元素用指针，动态分配
public:
Vector(int size=2):len(size){ //构造函数，把数组大小传入，分配内存
items=new T[len];
}
~Vector(){ //析构函数
delete[]items;items=NULL; //释放数组空间，指针置为空
}
void resize(int size){ //扩展数组的内存空间
if(size<=len)return; //只能往更大的扩展
T*tmp=new T[size]; //分配更大的目标数组
for(int ii=0;ii=len)resize(ii+10); //扩展数组空间
return items[ii];
}
const T& operator[](int ii)const{
return items[ii]; //重载操作符[]，形参是数组下标，不可以修改数组中的元素
}
};
int main()
{
//Vector大小为2，Stack大小为3
//创建一个对象Vector
Vector >v;//C++11之前，>>要加空格
//手工地往容器Vector插入数据
v[0].push("西施1");v[0].push("西施2");v[0].push("西施3");
v[1].push("西1");v[1].push("西2");v[1].push("西3");
//用for循环嵌套，把v容器中的数据显示出来
for(int i=0;i2）注意事项
①V类对象VS的定义
Vector >v;//C++11之前，>>要加空格
②V类对象VS元素的插入
v[0].push("西施1");v[0].push("西施2");v[0].push("西施3");
v[1].push("西1");v[1].push("西2");v[1].push("西3");
③V类对象VS元素的输出
//用for循环嵌套，把v容器中的数据显示出来
for(int i=0;i {
while(!v[i].isempty())//遍历Stack
{
string item;
v[i].pop(item);
cout<<"item= "< }
}
3）结果
（二）Vector大小为2，Stack大小为3；对Vector进行扩展；（深拷贝），对类的拷贝且类用到了堆区需要重写拷贝函数
//Vector有自动扩展功能 需要重写Stack的拷贝构造函数
//扩展Vector时，运行resize函数tmp[ii]=items[ii];Vector的数据类型为Stack，会用到Stack的拷贝构造函数
1）代码
#include
#include
using namespace std;
template //在类声明前加上模板的头部标签
class Stack //栈类
{
private: //3个成员变量
DataType *items; //栈数组，栈的元素用整数数组存放，动态分配一块数组空间
int stacksize; //栈大小，栈的大小用成员变量表示
int top; //栈顶指针，栈顶指针用整数表示，不是C++的指针
public: //成员函数
//构造函数：1）分配栈数组空间；2）把栈顶指针初始化为0
Stack(int size=3):stacksize(size),top(0) //需要一个参数（栈的大小），采用初始化列表对成员赋值
{
items=new DataType [stacksize]; //在构造函数中，给栈数组分配内存
}
~Stack() //析构函数，释放数组空间
{
delete []items; //释放数组空间
items=NULL; //指针置为空
}
Stack &operator=(const Stack&v)
{
delete []items;
stacksize=v.stacksize;
items=new DataType[stacksize];
for(int i=0;i0)
{
item=items[--top];
return true;
}
return false;
}
};
template
class Vector
{
private:
int len; //数组大小用成员变量表示
T *items; //数组元素用指针，动态分配
public:
Vector(int size=2):len(size){ //构造函数，把数组大小传入，分配内存
items=new T[len];
}
~Vector(){ //析构函数
delete[]items;items=NULL; //释放数组空间，指针置为空
}
void resize(int size){ //扩展数组的内存空间
if(size<=len)return; //只能往更大的扩展
T*tmp=new T[size]; //分配更大的目标数组
for(int ii=0;ii=len)resize(ii+1); //扩展数组空间
return items[ii];
}
const T& operator[](int ii)const{
return items[ii]; //重载操作符[]，形参是数组下标，不可以修改数组中的元素
}
};
int main()
{
//Vector大小为2，Stack大小为3，扩展Vector
//创建一个对象Vector
Vector >vs;//C++11之前，>>要加空格
//手工地往容器Vector插入数据
vs[0].push("西施1");vs[0].push("西施2");vs[0].push("西施3");
vs[1].push("西1");vs[1].push("西2");vs[1].push("西3");
vs[2].push("dad");//调用自动扩展函数resize
//用for循环嵌套，把v容器中的数据显示出来
for(int i=0;i vs[1].push("西1");vs[1].push("西2");vs[1].push("西3");
vs[2].push("dad");//调用自动扩展函数resize
④V类对象VS的输出
//用for循环嵌套，把v容器中的数据显示出来
for(int i=0;i {
while(!vs[i].isempty())//遍历Stack
{
string item;vs[i].pop(item);cout<<"item= "< }
}
3）结果
二、栈的成员是数组（入栈时需要拷贝数组，要写Vector的拷贝构造函数）
1）代码
//Vector有自动扩展功能 需要重写Stack的赋值构造函数
//扩展Vector时，resize函数tmp[ii]=items[ii];Vector的数据类型时Stack，会用到Stack的赋值函数
#include
#include
using namespace std;
// typedef string DataType;//定义栈元素的数据类型，后续不用具体的数据类型，而是使用DataType表示
//这么做的好处是如果要修改栈的数据类型，其他的代码不用修改，只要修改DataType就可以了
template //在类声明前加上模板的头部标签
class Stack //栈类
{
private: //3个成员变量
DataType *items; //栈数组，栈的元素用整数数组存放，动态分配一块数组空间
int stacksize; //栈大小，栈的大小用成员变量表示
int top; //栈顶指针，栈顶指针用整数表示，不是C++的指针
public: //成员函数
//构造函数：1）分配栈数组空间；2）把栈顶指针初始化为0
Stack(int size=3):stacksize(size),top(0) //需要一个参数（栈的大小），采用初始化列表对成员赋值
{
items=new DataType [stacksize]; //在构造函数中，给栈数组分配内存
}
~Stack() //析构函数，释放数组空间
{
delete []items; //释放数组空间
items=NULL; //指针置为空
}
Stack &operator=(const Stack&v)
{
delete []items;
stacksize=v.stacksize;
items=new DataType[stacksize];
for(int i=0;i0)
{
item=items[--top];
return true;
}
return false;
}
};
template
class Vector
{
private:
int len; //数组大小用成员变量表示
T *items; //数组元素用指针，动态分配
public:
Vector(int size=2):len(size){ //构造函数，把数组大小传入，分配内存
items=new T[len];
}
Vector & operator=(const Vector&v)
{
len=v.len;
delete[]items;
items=new T[len];
for(int i=0;i=len)resize(ii+1); //扩展数组空间
return items[ii];
}
const T& operator[](int ii)const{
return items[ii]; //重载操作符[]，形参是数组下标，不可以修改数组中的元素
}
};
int main()
{
//栈的大小是3，数组的大小可扩展
//创建一个Stack对象，
Stack >sv;
//栈的元素，临时Vector数组
Vectortmp;
//为栈元素（数组）赋值
tmp[0]="西施1";tmp[1]="西施2";sv.push(tmp);
tmp[0]="西瓜1";tmp[1]="西瓜2";sv.push(tmp);
tmp[0]="dad1";tmp[1]="dad2";tmp[2]="dad3";sv.push(tmp);//自动扩展
//循环打印出栈元素
while(!sv.isempty())
{
cout<<"nice"< tmp[0]="西瓜1";tmp[1]="西瓜2";sv.push(tmp);
tmp[0]="dad1";tmp[1]="dad2";tmp[2]="dad3";sv.push(tmp);//自动扩展
③S类对象SV的输出
//循环打印出栈元素
while(!sv.isempty())
{
cout<<"nice"< sv.pop(tmp);
for(int i=0;i cout<<"vs["< }
3）结果
三、数组的成员是数组 （数组赋值时需要用到数组的拷贝构造函数）
1）代码
//Vector有自动扩展功能 需要重写Stack的赋值构造函数
//扩展Vector时，resize函数tmp[ii]=items[ii];Vector的数据类型时Stack，会用到Stack的赋值函数
#include
#include
using namespace std;
// typedef string DataType;//定义栈元素的数据类型，后续不用具体的数据类型，而是使用DataType表示
//这么做的好处是如果要修改栈的数据类型，其他的代码不用修改，只要修改DataType就可以了
template //在类声明前加上模板的头部标签
class Stack //栈类
{
private: //3个成员变量
DataType *items; //栈数组，栈的元素用整数数组存放，动态分配一块数组空间
int stacksize; //栈大小，栈的大小用成员变量表示
int top; //栈顶指针，栈顶指针用整数表示，不是C++的指针
public: //成员函数
//构造函数：1）分配栈数组空间；2）把栈顶指针初始化为0
Stack(int size=3):stacksize(size),top(0) //需要一个参数（栈的大小），采用初始化列表对成员赋值
{
items=new DataType [stacksize]; //在构造函数中，给栈数组分配内存
}
~Stack() //析构函数，释放数组空间
{
delete []items; //释放数组空间
items=NULL; //指针置为空
}
Stack &operator=(const Stack&v)
{
delete []items;
stacksize=v.stacksize;
items=new DataType[stacksize];
for(int i=0;i0)
{
item=items[--top];
return true;
}
return false;
}
};
template
class Vector
{
private:
int len; //数组大小用成员变量表示
T *items; //数组元素用指针，动态分配
public:
Vector(int size=2):len(size){ //构造函数，把数组大小传入，分配内存
items=new T[len];
}
Vector & operator=(const Vector&v)
{
len=v.len;
delete[]items;
items=new T[len];
for(int i=0;i=len)resize(ii+1); //扩展数组空间
return items[ii];
}
const T& operator[](int ii)const{
return items[ii]; //重载操作符[]，形参是数组下标，不可以修改数组中的元素
}
};
int main()
{
//创建Vector容器，容器中的元素用Vector
Vector > vv;//递归使用模板类
//为数组元素（栈）赋值
vv[0][0]="西施1";vv[0][1]="西施1";vv[0][2]="西施1";vv[0][3]="西施1";
vv[1][0]="西瓜1";vv[1][1]="西瓜2";vv[1][2]="西瓜3";
vv[2][0]="dad1";vv[2][1]="dad2";vv[2][2]="dad3";
//循环输出数组元素
for(int i=0;i
2）注意事项
①V类对象VV的定义
//创建Vector容器，容器中的元素用Vector
Vector > vv;//递归使用模板类
②V类对象VV的插入
//为数组元素（栈）赋值
vv[0][0]="西施1";vv[0][1]="西施1";vv[0][2]="西施1";vv[0][3]="西施1";
vv[1][0]="西瓜1";vv[1][1]="西瓜2";vv[1][2]="西瓜3";
vv[2][0]="dad1";vv[2][1]="dad2";vv[2][2]="dad3";
③V类对象VV的输出
//循环输出数组元素
for(int i=0;i {
//循环输出栈元素
for(int j=0;j cout< cout< }
④类似二维数组，但是成员不是固定的
3）结果
