1. Toy模板网首页
  2. > Toy博客

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

8月前 作者：Crush_66 分类：Toy博客 阅读(19) 违法举报

这篇具有很好参考价值的文章主要介绍了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 <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）结果

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

（二）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）结果

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

二、栈的成员是数组（入栈时需要拷贝数组，要写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）结果

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

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

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

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

3）结果

C++类模板——嵌套使用文章来源地址https://www.toymoban.com/news/detail-452984.html

到了这里，关于C++类模板——嵌套使用的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 数据结构与算法—二叉树数组表示（ArrayBinTree）、二叉树的链式表示（LinkedBinTree）的基于C++模板代码实现

    1、二叉树的顺序表示：ArrayBinTree.h 二叉树的顺序表示法操作方便，但缺点是容易造成存储空间浪费。 这是一个用数组实现的二叉树类模板。它可以创建一个空树，也可以在指定的位置插入结点并设置结点的值，可以删除子树，并支持逐层遍历。使用该类时，需要提供一个元

    2024年02月06日
    浏览(32)

  • Hive解析嵌套JSON数组

    同时发生的埋点数据往往会在一个json字符串里发送，形式是[json，json，json]的埋点数组，需要把这些数据拉平 把最外层的\\\"[“和”]\\\"去除 把\\\"}，{“转换为”}|||{\\\" ，使用split函数根据\\\"|||\\\"把string转为array，LATERAL view explode()把array转为列 第二步的时候发现，内部的json数组也有\\\"}，

    2024年02月12日
    浏览(32)
  • 【C++】什么是模板？怎样使用模板？

    【C++】什么是模板？怎样使用模板？

    👀 樊梓慕： 个人主页  🎥 个人专栏： 《C语言》《数据结构》《蓝桥杯试题》《LeetCode刷题笔记》《实训项目》《C++》 🌝 每一个不曾起舞的日子，都是对生命的辜负 目录 前言 1.函数模板 1.1函数模板概念 1.2函数模板格式 1.3函数模板的实例化 1.4模板参数的匹配原则 2.类模

    2024年02月04日
    浏览(32)

  • Mongodb 对嵌套文档数组进行查询操作

    非嵌套文档的数组，数组由数字、字符串等元素组成。 以下方法对数组字段进行查询操作的示例，包括对数组匹配查询，元素的增、删、改操作，空数组、非空数组查询等。 连接到 mongodb 数据库， 创建集合 user， 批量插入如下测试数据 ： 在指定数组上的使用相等条件，请

    2024年02月17日
    浏览(33)
  • MongoDB原生语句更新嵌套数组的值

    MongoDB原生语句更新嵌套数组的值

    首先执行MongoDB原生语句脚本在user集合中产生一些样本数据，如下所示： 如果想将 “ 吕子乔 ” 修改为 “ 曾小贤 ” ，则可以执行下述脚本进行数据更新： 这时再次查看user集合，可以看到数据已经更新： 此处使用了$符号，$符号表示的是一个占位符，代表被匹配的数组中的

    2024年02月15日
    浏览(32)

  • 二维数组多次排序 或 嵌套list多次排序

    可以排序int[ ][ ]的顺序，也可以排序ListListInteger 顺序 为便于理解，以力扣原题为例：1333.餐厅过滤器 原题中给了一个双重数组，并要求返回一个ListInteger。 方法1 ： 会用流的，通常用于会反应把双重数组转成ListListInteger去处理这个双重数组，于是解题思路如下： 可是该方式

    2024年02月07日
    浏览(29)

  • c++模板编程2-函数模板的定义和使用

    两阶段编译检查 在实例化模板的时候，如果模板的参数类型不支持模板中用到的操作符，将会遇到编译期错误，例： 以上例子 add(a, b) 会在编译器报错，但在模板定义的地方并没有出现错误提示，这是因为模板是分两步编译的： 在模板定义阶段，模板的检查并不包含类型参

    2024年02月06日
    浏览(22)
  • vue +element UI form表单校验数组嵌套，数组对象必填校验

    vue +element UI form表单校验数组嵌套，数组对象必填校验

    使用element表单时会出现数组对象类型的数据结构并且需要必填校验 这时数组对象的检验方法就为paramJsonListRules 注意的是为了实现校验，在需要校验的el-form-item内通过自己的:rules加入对象的校验方法，例如图中想给参数值加校验则直接在相关el-form-item内加入 :rules=\\\"paramJsonLis

    2024年02月11日
    浏览(52)
  • C语言可变数组 嵌套的可变数组，翻过了山跨过了河 又掉进了坑

    C语言可变数组 嵌套的可变数组，翻过了山跨过了河 又掉进了坑

    ​ 专栏内容 ： postgresql内核源码分析 手写数据库toadb 并发编程 个人主页 ：我的主页 座右铭：天行健，君子以自强不息；地势坤，君子以厚德载物. 数组中元素是顺序存放，这一特性让我们存储和访问数据都很简单， 但也因为这一特性，我们在写代码时，往往不能确定数组

    2024年02月12日
    浏览(26)

  • 椋鸟C语言笔记#31：结构体（联合体）嵌套、柔性数组

    萌新的学习笔记，写错了恳请斧正。 目录 结构体（联合体）嵌套 嵌套时内嵌结构体（联合体）不创建变量（匿名） 嵌套时内嵌结构体（联合体）创建变量（非匿名） 嵌套初始化 柔性数组 柔性数组的使用 结构体（联合体）嵌套 结构体、联合体可以嵌套，也就是说结构体（

    2024年02月02日
    浏览(38)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包