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

news2024/12/26 21:22:39

目录

类模板的嵌套分类

一、数组的成员是栈

（一）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;
    }

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

3）结果

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/542441.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

代码随想录算法训练营第四十五天 | dp最小值题目

代码随想录算法训练营第四十五天 | dp最小值题目

70. 爬楼梯 的改进版 改进条件 改为&#xff1a;一步一个台阶&#xff0c;两个台阶&#xff0c;三个台阶&#xff0c;…&#xff0c;直到 m个台阶。问有多少种不同的方法可以爬到楼顶呢&#xff1f; 文档讲解&#xff1a;代码随想录 (programmercarl.com) 状态&#xff1a;能…
阅读更多...
IS420ESWBH3A DIN导轨或潜在面板安装

IS420ESWBH3A DIN导轨或潜在面板安装

马克维耶斯IONet交换机IS420ESWBH3A由通用电气公司生产&#xff0c;工作在24/28 VDC&#xff0c;这种型号没有任何光纤端口&#xff0c;但有16个铜端口。IS420ESWBH3A开关在DIN导轨安装时需要安装夹&#xff0c;在面板安装时只需要螺钉。 IS420ESWBH3A技术规范 光纤端口数量没…
阅读更多...
chatgpt赋能Python-python3_10安装numpy

chatgpt赋能Python-python3_10安装numpy

Python3.10安装numpy&#xff1a;一步一步教你如何轻松完成 Python3.10虽然已经发布了&#xff0c;但是有些模块还需要手动安装&#xff0c;例如numpy。在这篇文章中&#xff0c;我们将会详细介绍如何安装numpy模块&#xff0c;以及为什么要使用numpy模块。 什么是numpy模块&…
阅读更多...
Redis教程-基础篇

Redis教程-基础篇

第一部分&#xff1a;入门 1.1 Redis简介 Redis&#xff08;Remote Dictionary Server&#xff09;是一个高性能的键值存储系统&#xff0c;它是一种开源、基于内存的数据结构服务器。Redis以其出色的性能和灵活的数据结构而受到广泛关注和应用。下面展开描述Redis的定义和特…
阅读更多...
chatgpt赋能Python-python3gui

chatgpt赋能Python-python3gui

Python3 GUI- 让你的应用程序更酷炫 随着技术的发展&#xff0c;图形用户界面(Graphical User Interface, GUI)已经成为软件开发过程中不可或缺的一部分。Python3是一个用于快速开发应用程序的强大编程语言&#xff0c;支持多种GUI库。本文将为您介绍Python3 GUI的一些基本概念…
阅读更多...
web安全第一天 ，域名，dns

web安全第一天 ，域名，dns

第一天 什么是域名&#xff1f;域名就是网络地址 在hhtp之后的就是域名 域名在哪里注册呢 国内注册商有很多&#xff0c;在网络上搜索一下阿里云万网就可以注册 什么是二级域名和多级域名 域名通常都是www.开头 &#xff0c;而www.被称为顶级域名&#xff0c;在搜索的时候…
阅读更多...
【云计算与虚拟化】第五章 实验一 vCenter Server的高级功能—vMotion、虚拟内存、虚拟CPU、磁盘分配及资源池

【云计算与虚拟化】第五章 实验一 vCenter Server的高级功能—vMotion、虚拟内存、虚拟CPU、磁盘分配及资源池

实验一 vCenter Server的高级功能—vMotion、虚拟内存、虚拟CPU、磁盘分配及资源池 1.通过vSphere client 客户端登陆vCenter服务器 &#xff08;1&#xff09;再次新建一个共享存储&#xff0c;iSCSI类型的&#xff0c;大小60G&#xff0c;名称为iSCSI-2。 &#xff08;2…
阅读更多...
C++模板类与函数

C++模板类与函数

目录 分类 一、普通函数&#xff0c;参数和返回值是模板类的实例化版本&#xff08;只支持AA模板类的某一个具体化类&#xff09; 1&#xff09;代码 2&#xff09;分析 3&#xff09;运行结果 二、函数模板&#xff0c;参数和返回值是某种模板类&#xff08;只支持AA模板…
阅读更多...
chatgpt赋能Python-python31个关键词

chatgpt赋能Python-python31个关键词

Python 31个关键词: 了解Python编程的基础知识 Python是一种高级编程语言&#xff0c;首次推出于1991年。自那时以来&#xff0c;Python已经成为最受欢迎的编程语言之一&#xff0c;它具有易读性、易维护性和清晰的语法。在这篇文章中&#xff0c;我们将介绍Python的31个关键词…
阅读更多...
python3.8 安装 ssl 模块 和 _ctypes 模块

python3.8 安装 ssl 模块 和 _ctypes 模块

文章目录 前情提要安装 openssl-1.1.1重新编译安装 python3.8-rpath 编译选项介绍python3.8 跟 python3.10 的区别 前情提要 在我成功给 python3.10 安装 ssl 模块后自以为是的写下了 “虽然我编译的是 python3.10&#xff0c;但是对于 python3.6、python3.8 应该同样适用。”…
阅读更多...
chatgpt赋能Python-python3_0怎么安装

chatgpt赋能Python-python3_0怎么安装

Python3.0怎么安装 Python3.0是一个优秀的编程语言&#xff0c;其简单易学&#xff0c;易用性强&#xff0c;且具有强大的功能和广泛的应用。如果您需要在您的电脑上使用Python3.0&#xff0c;本文将为您介绍如何进行安装。 下载Python3.0 首先&#xff0c;您需要从官方网站…
阅读更多...
教育不得不改变，ChatGPT可以提供个性化学习

教育不得不改变，ChatGPT可以提供个性化学习

近日&#xff0c;OpenAI的首席执行官Sam Altman接受ABC新闻首席商业、技术和经济记者Rebecca Jarvis的独家采访。Sam Altman提到了对错误信息的担忧、探讨了人工智能与人类工作的关系、ChatGPT与教育的关系等。 ChatGPT今年1月面世后&#xff0c;在短短几个月内就达到了1亿月活…
阅读更多...
代码随想录训练营Day43| 1049. 最后一块石头的重量 II 494. 目标和 474.一和零

代码随想录训练营Day43| 1049. 最后一块石头的重量 II 494. 目标和 474.一和零

目录 学习目标 学习内容 1049. 最后一块石头的重量 II 494. 目标和 474.一和零 学习目标 1049. 最后一块石头的重量 II 494. 目标和 474.一和零 学习内容 1049. 最后一块石头的重量 II 1049. 最后一块石头的重量 II - 力扣&#xff08;LeetCode&#xff09;https://l…
阅读更多...
【云计算与虚拟化】第三章 实验二 在ESXi主机中安装操作系统

【云计算与虚拟化】第三章 实验二 在ESXi主机中安装操作系统

实验二 在ESXi主机中安装操作系统 为ESXi主机添加一块数据存储磁盘&#xff0c;大小为80G&#xff0c;磁盘名称为&#xff1a;ESXi-loc-80G&#xff08;截图&#xff09; 2.登录vSphere Client&#xff0c;加载新添加的数据存储磁盘&#xff0c;加载大小为60G&#xff0c;并将…
阅读更多...
网络编程——嵌入式（驱动）软开基础（五）

网络编程——嵌入式（驱动）软开基础（五）

1. 列举一下OSI协议的各种分层。说说你最熟悉的一层协议的功能。 （1）七层划分为：应用层、表示层、会话层、传输层、网络层、数据链路层、物理层。 （2）五层划分为：应用层、传输层、网络层、数据链路层、物理层。 （3）四层划分为：应用层、传输层、网络层、网络接口层。（…
阅读更多...
springboot+java+jsp校园二手书旧书交易交换系统

springboot+java+jsp校园二手书旧书交易交换系统

前台功能&#xff1a;用户进入系统可以对首页、书籍信息、校园公告、个人中心、后台管理等功能进行操作&#xff1b; 后台主要是管理员&#xff0c;管理员功能包括主页、个人中心、学生管理、发布人管理、书籍分类管理、书籍信息管理、交易信息管理、交换信息管理、系统管理等&…
阅读更多...
Linux运维常用grep命令使用

Linux运维常用grep命令使用

grep 命令是 Linux 运维中非常常见的文本搜索工具 常用的使用方法如下&#xff1a; 1、查找包含指定字符串的行 grep "pattern" file.txt 其中&#xff0c;pattern 是要查找的字符串&#xff0c;file.txt 是要搜索的文件名。 2、查找不包含指定字符串的行 grep -v…
阅读更多...
chatgpt赋能Python-python3_9_2怎么换行

chatgpt赋能Python-python3_9_2怎么换行

Python 3.9.2 换行方法 Python 3.9.2 已经出现了&#xff0c;除了一些修复和新功能&#xff0c;Python 3.9.2 还包括了一些在换行方面的改进。在本文中&#xff0c;我们将介绍 Python 3.9.2 中换行的新方法。 换行符 在 Python 3.9.2 中&#xff0c;我们可以使用换行符来实现…
阅读更多...
chatgpt赋能Python-python3_10下载安装

chatgpt赋能Python-python3_10下载安装

Python3.10&#xff1a;开发者首选 对于每个开发者来说&#xff0c;选择合适的编程语言是至关重要的。在众多可供选择的编程语言中&#xff0c;Python一直是最受欢迎的选择之一。为什么Python如此受欢迎&#xff1f;因为其简单易学、代码可读性强、广泛的库支持和适用于各种应…
阅读更多...
【Git相关命令】

【Git相关命令】

git全局设置 作用是用于描述git使用者的身份。注意&#xff0c;设置的用户名和邮箱跟代码托管平台的用户名和邮箱没有任何关系。 git config --global user.name "用户名" git config --global user.email "邮箱地址"获取git仓库 方式1&#xff1a;将本地的…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023