C++类模板——嵌套使用

可爱多咻雪糕

已于 2023-05-17 20:46:45 修改

阅读量2.6k

点赞数

分类专栏： C++ 文章标签： c++ 算法数据结构

于 2023-05-17 20:43:14 首次发布

本文链接：https://blog.csdn.net/Crush_66/article/details/130732817

版权

C++ 专栏收录该内容

15 篇文章 1 订阅

订阅专栏

文章详细探讨了C++中使用模板类实现栈和数组的嵌套，包括数组的成员是栈、栈的成员是数组以及数组的成员是数组三种情况。在不同场景下，涉及到了浅拷贝和深拷贝的概念，以及何时需要重写拷贝构造函数来处理堆区的对象。代码示例展示了如何在栈操作中扩展数组，并处理数据类型的拷贝和内存管理。

摘要由CSDN通过智能技术生成

类模板的嵌套分类

一、数组的成员是栈

（一）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 <iostream>
#include<string>
using namespace std;
//栈类
template <class DataType>//在类声明前加上模板的头部标签
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(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=NULL;        //释放数组空间，指针置为空
		}
		void resize(int size){            //扩展数组的内存空间
			if(size<=len)return;            //只能往更大的扩展
			T*tmp=new T[size];                //分配更大的目标数组
			for(int ii=0;ii<len;ii++)        //将原来的数组赋给目标数组
				tmp[ii]=items[ii];
			delete[]items;                //释放原来的数组
			items=tmp;                    //让数组指向新的目标数组
			len=size;
		}
		int size()const{                //获取数组长度
            return len;
		}
		T& operator[](int ii){            //重载操作符[]，形参是数组下标，可以修改数组中的元素
		    if(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<Stack<string> >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;i<v.size();i++)//遍历Vector
	{
		while(!v[i].isempty())//遍历Stack
		{
			string item;
			v[i].pop(item);
			cout<<"item= "<<item<<endl;
		}
	}
	return 0;
}

2）注意事项

①V类对象VS的定义

Vector<Stack<string> >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<v.size();i++)//遍历Vector
   {
       while(!v[i].isempty())//遍历Stack
       {
           string item;
           v[i].pop(item);
           cout<<"item= "<<item<<endl;
       }
   }

3）结果

（二）Vector大小为2，Stack大小为3；对Vector进行扩展；（深拷贝），对类的拷贝且类用到了堆区需要重写拷贝函数

//Vector有自动扩展功能需要重写Stack的拷贝构造函数
//扩展Vector时，运行resize函数tmp[ii]=items[ii];Vector的数据类型为Stack，会用到Stack的拷贝构造函数

1）代码

#include <iostream>
#include<string>
using namespace std;

template <class DataType>//在类声明前加上模板的头部标签
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;i<stacksize;i++)items[i]=v.items[i];
		top=v.top;
		return *this;
	}
	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;
	}		
};

 
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=NULL;        //释放数组空间，指针置为空
		}
		void resize(int size){            //扩展数组的内存空间
			if(size<=len)return;            //只能往更大的扩展
			T*tmp=new T[size];                //分配更大的目标数组
			for(int ii=0;ii<len;ii++)        //将原来的数组赋给目标数组
				tmp[ii]=items[ii];
			delete[]items;                //释放原来的数组
			items=tmp;                    //让数组指向新的目标数组
			len=size;
		}
		int size()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

	//创建一个对象Vector
	Vector<Stack<string> >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.size();i++)//遍历Vector
	{
		while(!vs[i].isempty())//遍历Stack
		{
			string item;vs[i].pop(item);cout<<"item= "<<item<<endl;
		}
	}
	return 0;
}

2）注意事项

①V类对象VS的定义

Vector<Stack<string> >vs;//C++11之前，>>要加空格

②重写的拷贝构造函数（深拷贝）

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

③V类对象VS的插入

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

④V类对象VS的输出

//用for循环嵌套，把v容器中的数据显示出来
   for(int i=0;i<vs.size();i++)//遍历Vector
   {
       while(!vs[i].isempty())//遍历Stack
       {
           string item;vs[i].pop(item);cout<<"item= "<<item<<endl;
       }
   }

3）结果

二、栈的成员是数组（入栈时需要拷贝数组，要写Vector的拷贝构造函数）

1）代码

//Vector有自动扩展功能   需要重写Stack的赋值构造函数
//扩展Vector时，resize函数tmp[ii]=items[ii];Vector的数据类型时Stack，会用到Stack的赋值函数
#include <iostream>
#include<string>
using namespace std;
// typedef string DataType;//定义栈元素的数据类型，后续不用具体的数据类型，而是使用DataType表示
//这么做的好处是如果要修改栈的数据类型，其他的代码不用修改，只要修改DataType就可以了
template <class DataType>//在类声明前加上模板的头部标签
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;i<stacksize;i++)items[i]=v.items[i];
		top=v.top;
		return *this;
	}
	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;
	}		
};

 
template <class T>
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;i++)
			items[i]=v.items[i];
			return *this;
		}
		~Vector(){                        //析构函数
		    delete[]items;items=NULL;        //释放数组空间，指针置为空
		}
		void resize(int size){            //扩展数组的内存空间
			if(size<=len)return;            //只能往更大的扩展
			T*tmp=new T[size];                //分配更大的目标数组
			for(int ii=0;ii<len;ii++)        //将原来的数组赋给目标数组
				tmp[ii]=items[ii];
			delete[]items;                //释放原来的数组
			items=tmp;                    //让数组指向新的目标数组
			len=size;
		}
		int size()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()
{
    //栈的大小是3，数组的大小可扩展
	
	//创建一个Stack对象，
	Stack<Vector<string> >sv;

    //栈的元素，临时Vector<string>数组
	 Vector<string>tmp;

    //为栈元素（数组）赋值
	 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"<<endl;
	 	sv.pop(tmp);

        //循环打印出数组元素
	 	for(int i=0;i<tmp.size();i++)
	 	cout<<"vs["<<i<<"]="<<tmp[i]<<endl;
	 }
	return 0;
}

2）注意事项

①Vector的拷贝构造函数

bool push(const DataType& item)函数中的语句items[top++]=item使用Vector的拷贝构造函数;

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

①S类对象SV的定义

//创建一个Stack对象，
Stack<Vector<string> >sv;

②S类对象SV的插入

//栈的元素，临时Vector<string>数组
   Vector<string>tmp;

//为栈元素（数组）赋值
   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);//自动扩展

③S类对象SV的输出

//循环打印出栈元素

while(!sv.isempty())
   {
      cout<<"nice"<<endl;
      sv.pop(tmp);
      for(int i=0;i<tmp.size();i++)
      cout<<"vs["<<i<<"]="<<tmp[i]<<endl;
   }

3）结果

三、数组的成员是数组（数组赋值时需要用到数组的拷贝构造函数）

1）代码

//Vector有自动扩展功能   需要重写Stack的赋值构造函数
//扩展Vector时，resize函数tmp[ii]=items[ii];Vector的数据类型时Stack，会用到Stack的赋值函数
#include <iostream>
#include<string>
using namespace std;
// typedef string DataType;//定义栈元素的数据类型，后续不用具体的数据类型，而是使用DataType表示
//这么做的好处是如果要修改栈的数据类型，其他的代码不用修改，只要修改DataType就可以了
template <class DataType>//在类声明前加上模板的头部标签
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;i<stacksize;i++)items[i]=v.items[i];
		top=v.top;
		return *this;
	}
	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;
	}		
};

 
template <class T>
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;i++)
			items[i]=v.items[i];
			return *this;
		}
		~Vector(){                        //析构函数
		    delete[]items;items=NULL;        //释放数组空间，指针置为空
		}
		void resize(int size){            //扩展数组的内存空间
			if(size<=len)return;            //只能往更大的扩展
			T*tmp=new T[size];                //分配更大的目标数组
			for(int ii=0;ii<len;ii++)        //将原来的数组赋给目标数组
				tmp[ii]=items[ii];
			delete[]items;                //释放原来的数组
			items=tmp;                    //让数组指向新的目标数组
			len=size;
		}
		int size()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容器，容器中的元素用Vector<string>
	Vector<Vector<string> > 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<vv.size();i++)
	{
        //循环输出栈元素
		for(int j=0;j<vv[i].size();j++)
			cout<<vv[i][j]<<" ";
			cout<<endl;
	}
	return 0;
}

2）注意事项

①V类对象VV的定义

//创建Vector容器，容器中的元素用Vector<string>
Vector<Vector<string> > 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<vv.size();i++)
   {
//循环输出栈元素
       for(int j=0;j<vv[i].size();j++)
           cout<<vv[i][j]<<" ";
           cout<<endl;
   }

④类似二维数组，但是成员不是固定的