容器（续）

最新推荐文章于 2024-08-28 17:47:34 发布
最新推荐文章于 2024-08-28 17:47:34 发布
阅读量72 收藏
点赞数
分类专栏： c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50934744/article/details/115306778
版权
c语言 同时被 2 个专栏收录
101 篇文章 21 订阅
订阅专栏
c++
57 篇文章 2 订阅
订阅专栏
本文介绍了C++容器中insert()函数的三种用法，包括在指定位置插入单个元素、多个相同元素以及一个元素区间。接着详细讲解了pair函数的定义、访问和赋值方式。同时，探讨了erase函数的三种删除操作，并提到了GetStdHandle和SetConsoleCursorPosition在命令行中的应用。
摘要由CSDN通过智能技术生成 
//vector简单元素 
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <vector>
#include <algorithm>
#include <numeric>
using namespace std;

class test
{
private:
	vector<int>a;
	vector<int>::iterator p;
	int n,i;
public:
	test(int nn)
	{
		n=nn;
		srand(time(0));
		for(i=0;i<n;++i)
		{
			a.push_back(rand());
		}
	}
	static bool cmp(int n1,int n2)
	{
		return n1>n2;
	}//两数比较，返回大的
	void browse()
	{
		for(p=a.begin();p!=a.end();++p)//指针指向开头，遍历到末尾，依次输出
		{
			cout<<*p<<endl;
		}
	}
	void Sort()
	{
		sort(a.begin(),a.end(),cmp);
	}
	void Find()
	{
		int temp;
		cout<<"input find number:";cin>>temp;
		p=a.begin();
		while(true)
		{
			p=find(p,a.end(),temp);//第一个参数是p的起始地址，第二个参数是p的结束地址，第三个参数是需要查找的值
			if(p!=a.end())
			{
				cout<<*p<<endl;
				++p;
			}
			else break;
		}
	}	
	void Erase()
	{
		p=a.end()-2;
		a.erase(p);
	}
//erase有三种用法：
//（1）erase(pos, n); 删除从pos开始的n个字符，比如erase(0, 1)就是删除第一个字符
//（2）erase(position); 删除position处的一个字符(position是个string类型的迭代器)
//（3）erase(first, last); 删除从first到last之间的字符（first和last都是迭代器）
};

int main()
{
	test t(100);
//	t.Sort();
//	t.Find();
	t.browse();
	cout<<"===================="<<endl;
	t.Erase();
	t.browse();
	return 0;
}

//vector复合元素 
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <vector>
#include <algorithm>
#include <numeric>
using namespace std;
struct S//结构体
{
	int index;//加入此项可实现任意字段检索 
	int number;
	int score;
	bool operator==(S s)
	{
		if(s.index==1)//在这里使用 
			return number==s.number;
		else if(s.index==2)
			return score==s.score;
	}
};
class test
{
private:
	vector<S>a;
	vector<S>::iterator p;
	int n,i;
public:
	test(int nn)
	{
		n=nn;
		srand(time(0));
		S t;
		for(i=0;i<n;++i)
		{
			t.number=rand();
			t.score=rand();
			a.push_back(t);
		}
	}
	static bool cmp(S s1,S s2)
	{
		return s1.score>s2.score;
	}//两结构体的score数值比较，返回较大的值
	void browse()
	{
		for(p=a.begin();p!=a.end();++p)
		{
			cout<<p->number<<"-"<<p->score<<endl;
		}
	}
	void Sort()
	{
		sort(a.begin(),a.end(),cmp);
	}//从高到低排序
	void Find()
	{
		S temp;
		cout<<"input find:";cin>>temp.number;
		temp.index=1;
		p=a.begin();
		while(true)
		{
			p=find(p,a.end(),temp);
			if(p!=a.end())
			{
				cout<<p->number<<"-"<<p->score<<endl;
				++p;
			}
			else break;
		}
	}	
	void Erase()
	{
		p=a.end()-2;
		a.erase(p);
	}
};

int main()
{
	test t(100000);
//	t.Sort();
	t.Find();
//	t.browse();
//	cout<<"===================="<<endl;
//	t.Erase();
//	t.browse();
	return 0;
}

//list简单元素 
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <vector>
#include <list>
#include <algorithm>
#include <numeric>
using namespace std;

class test
{
private:
	list<int>a;
	list<int>::iterator p;
	int n,i;
public:
	test(int nn)
	{
		n=nn;
		srand(time(0));
		for(i=0;i<n;++i)
		{
			a.push_back(rand());
		}
	}	
	void browse()
	{
		for(p=a.begin();p!=a.end();++p)
		{
			cout<<*p<<endl;
		}
	}
	void Find()
	{
		int temp;
		cout<<"input:";cin>>temp;
		p=a.begin();
		while(true)
		{
			p=find(p,a.end(),temp);//第一个参数是p的起始地址，第二个参数是p的结束地址，第三个参数是需要查找的值
			if(p!=a.end())
			{
				cout<<*p<<endl;
				++p;
			}
			else break;
		}
	}
	void Erase()
	{
		p=a.end();
		--p;--p;
		a.erase(p);
	}
	void Insert()
	{
		p=a.end();
		--p;
		a.insert(p,12345);
	}
};
int main()
{
	test t(10);
	t.browse();
//	t.Find();
	cout<<"==============="<<endl;
	t.Erase();
	t.browse();
	cout<<"==============="<<endl;
	t.Insert();
	t.browse();
	return 0;
}

C++容器的insert()函数有以下三种用法: 最终*it=val;
用法1:在指定位置it前“插入”值为val的元素,返回指向这个元素的迭代器,
iterator insert( iterator it, const TYPE &val );

用法2:在指定位置it前“插入”num个值为val的元素
void insert( iterator it, size_type num, const TYPE &val );

用法3:在指定位置it前“插入”区间[start, end)的所有元素.
void insert( iterator it, input_iterator start, input_iterator end );

//list复合元素 
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <vector>
#include <list>
#include <algorithm>
#include <numeric>
using namespace std;

struct S
{
	int number;
	int score;
	bool operator==(S s)
	{
		return score==s.score;
	}
}; 
class test
{
private:
	list<S>a;
	list<S>::iterator p;
	int n,i;
public:
	test(int nn)
	{
		n=nn;
		srand(time(0));
		S t;
		for(i=0;i<n;++i)
		{
			t.number=rand();t.score=rand();
			a.push_back(t);
		}
	}	
	void browse()
	{
		for(p=a.begin();p!=a.end();++p)
		{
			cout<<p->number<<"-"<<p->score<<endl;
		}
	}
	void Find()
	{
		S temp;
		cout<<"input:";cin>>temp.score;
		p=a.begin();
		while(true)
		{
			p=find(p,a.end(),temp);//第一个是地址的起点，第二个是地址的终点，第三个是要查找的量
			if(p!=a.end())
			{
				cout<<p->number<<"-"<<p->score<<endl;
				++p;
			}
			else break;
		}
	}
};
int main()
{
	test t(100000);
//	t.browse();
	t.Find();
	return 0;
}

与上一个编码相比，变量从一个变成了两个（多个），但是大体的思路是不变的，过程也是基本一样的。因为“容器”可以分开存放不同类变量。

//map简单元素 
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <map>
#include <algorithm>
#include <numeric>
using namespace std;

class test
{
private:
	map<int,int>a;
	map<int,int>::iterator p;
	int n,i;
public:
	test(int nn)
	{
		n=nn;
		srand(time(0));
		for(i=0;i<n;++i)
		{
			a.insert(pair<int,int>(rand(),rand()));
		}
	}
	void browse()
	{
		for(p=a.begin();p!=a.end();++p)
		{
			cout<<p->first<<"-"<<p->second<<endl;//用来访问pair中的两个值
		}
	}
	void Find()
	{
		int temp;
		cout<<"input key:";cin>>temp;
		p=a.begin();
		p=a.find(temp);
		if(p!=a.end())
		{
			cout<<p->first<<"-"<<p->second<<endl;
		}
		else 
		{
			cout<<"no record!"<<endl;
		}
	}
};

int main()
{
	test t(100000);
//	t.browse();
	t.Find();
	return 0;
}

pair函数：
类模板：template <class T1, class T2> struct pair
参数：class T1是第一个值的数据类型，class T2是第二个值的数据类型。
功能：pair将一对值（可以是不同的数据类型）组合成一个值，两个值可以分别用pair的两个公有函数first和second访问。

具体用法：
1.定义（构造）：
pair<int, double> p1; //使用默认构造函数
pair<int, double> p2(1, 2.4); //用给定值初始化
pair<int, double> p3(p2); //拷贝构造函数

2.访问两个元素（通过first和second）：
pair<int, double> p1; //使用默认构造函数
p1.first = 1;
p1.second = 2.5;
cout << p1.first << ’ ’ << p1.second << endl;
输出结果：1 2.5

3.赋值：
（1）利用make_pair：
pair<int, double> p1;
p1 = make_pair(1, 1.2);
（2）变量间赋值：
pair<int, double> p1(1, 1.2);
pair<int, double> p2 = p1;
（3）生成新的pair对象：
可以使用make_pair对已存在的两个数据构造一个新的pair类型：
int a = 8;
string m = “James”;
pair<int, string> newone;
newone = make_pair(a, m);
注意：使用关于pair函数中的字符串时，定义字符串用string a;a是字符串的名称。

//map复合元素 
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <map>
#include <algorithm>
#include <numeric>
using namespace std;

struct S
{
	int number;
	int score;
};

class test
{
private:
	map<int,S>a;
	map<int,S>::iterator p;
	int n,i;
public:
	test(int nn)
	{
		n=nn;
		srand(time(0));
		S t;
		for(i=0;i<n;++i)
		{
			t.number=rand();t.score=rand();
			a.insert(pair<int,S>(i,t));//插入的第一个是int i，第二个是结构体S t
		}
	}
	void browse()
	{
		for(p=a.begin();p!=a.end();++p)
		{
			cout<<p->first<<"-"<<p->second.number<<"-"
								<<p->second.score<<endl;
		}
	}
	void Find()
	{
		int temp;
		cout<<"input key:";cin>>temp;
		p=a.begin();
		p=a.find(temp);
		if(p!=a.end())
		{
			cout<<p->first<<"-"<<p->second.number<<"-"
								<<p->second.score<<endl;
		}
		else 
		{
			cout<<"no record!"<<endl;
		}
	}
};

int main()
{
	test t(100);
	t.browse();
	t.Find();
	return 0;
}

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <vector>
#include <numeric>
#include <algorithm>
#include <conio.h>
using namespace std;

class test
{
private:
	vector<int>a;
	vector<int>::iterator p;
	char c;
public:
	test()
	{
		int i;
		srand(time(0));
		for(i=0;i<5;++i)
		{
			a.push_back(rand());
		}
	}
	void browse()
	{
		for(p=a.begin();p!=a.end();++p)
			cout<<*p<<endl;
	}
	void show()
	{
		browse();
		while(true)
		{
			c=getch();
			if(c==27) break;
			if(c==32)
			{
				a.push_back(rand());
				p=a.begin();
				a.erase(p);
				system("cls");//调用DOS下的清屏命令，清空屏幕
				browse();
			}
		}
	}
};
int main()
{
	test t;
	t.show();
	return 0;
}

erase函数的原型如下：

（1）string& erase ( size_t pos = 0, size_t n = npos );

（2）iterator erase ( iterator position );

（3）iterator erase ( iterator first, iterator last );

也就是说有三种用法：

（1）erase(pos,n); 删除从pos开始的n个字符，比如erase(0,1)就是删除第一个字符

（2）erase(position);删除position处的一个字符(position是个string类型的迭代器)

（3）erase(first,last);删除从first到last之间的字符（first和last都是迭代器）

#include <iostream>
#include <cstdlib>
#include <list>
#include <numeric>
#include <string>
#include <algorithm>
using namespace std;

struct S
{
	int number;
	string name;
	double score;
	bool operator==(double d)
	{
		return (score>d);
	}
};

class test
{
private:
	list<S>a;
	list<S>::iterator p;
public:
	test()
	{
		S t;
		t.number=1;t.name="张一";t.score=87;a.push_back(t);
		t.number=2;t.name="张二";t.score=92;a.push_back(t);
		t.number=3;t.name="张三";t.score=75;a.push_back(t);
		t.number=4;t.name="张四";t.score=95;a.push_back(t);
	}
	void browse()
	{
		for(p=a.begin();p!=a.end();++p)
			cout<<p->number<<"-"<<p->name<<"-"<<p->score<<endl;
	}
	void Find(double d) 
	{
		p=a.begin();
		while(1)
		{
			p=find(p,a.end(),d); 
			if(p!=a.end())
			{
				cout<<p->number<<"-"<<p->name<<"-"<<p->score<<endl;
				++p;
			}
			else
			{
				break;
			}
		}
	}
};
int main()
{
	test t;
	t.browse();
	cout<<"=============="<<endl;
	t.Find(90);
	return 0;
}

#include <iostream>
#include <cstdlib>
#include <string>
#include <map>
#include <algorithm>
#include <numeric>
using namespace std;

struct S
{
	string name;
	double score;	
};

class test
{
private:
	map<string,S>a;
	map<string,S>::iterator p;
public:
	test()
	{
		S t;
		t.name="张一";t.score=87;a.insert(pair<string,S>("001",t));
		t.name="张二";t.score=92;a.insert(pair<string,S>("002",t));
		t.name="张三";t.score=75;a.insert(pair<string,S>("003",t));
		t.name="张四";t.score=95;a.insert(pair<string,S>("004",t));
	}
	void browse()
	{
		for(p=a.begin();p!=a.end();++p)
			cout<<p->first<<"-"
				<<(p->second).name<<"-"
				<<(p->second).score<<endl;
	} 
	void Find(string s) 
	{
		p=a.find(s); 
		if(p!=a.end())
		{
			cout<<p->first<<"-"
				<<(p->second).name<<"-"
				<<(p->second).score<<endl;
		}
		else
		{
			cout<<"No person!"<<endl;
		}
	}
};

int main()
{
	test t;
	t.browse();
	cout<<"=============="<<endl;
	t.Find("003");//注意，这里要用双引号括起来
	cout<<"=============="<<endl;
	t.Find("005");
	return 0;
}


在这里插入代码片

GetStdHandle返回一个指向标准输入，输出或错误处理的句柄（或是经过SetStdHanlde修改的指向特殊设备的句柄）。
其接受的参数有三种：STD_INPUT_HANDLE, STD_OUTPUT_HANDLE, STD_ERROR_HANDLE。
① STD_INPUT_HANDLE : 通常为标准输入的控制台缓冲区。
② STD_OUTPUT_HANDLE : 通常为标准输出的屏幕。
③ STD_ERROR_HANDLE : 通常是标准输出的屏幕，打印错误信息。
这些参数的值可以通过SetStdHandle函数来修改。

*SetConsoleCursorPosition()来自于文件"windows.h"。这个函数的功能是移动命令行中光标的位置。这里要注意的是，每次调用这个函数都是默认从左上角开始偏移，而与当前光标停留的位置无关。调用这个函数需要传入两个参数，都是自定义类型，分别为 HANDLE 和 COORD。
HANDLE即是void的重定义，typedef void *HANDLE。但是在将其传入前，我们需要使这个指针变成一个windows输出的句柄HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);//获取标准输出句柄。
COORD是一个类的重定义，里面包含是两个short型，当然这里传入的XY就是之后光标在命令行里偏移的单位。比如X=1时，光标向右移动一个单位，比如Y=1时，光标向下移动一个单位。

//射击小游戏 
#include <windows.h>
#include <ctime>
#include <vector>
#include <iostream>
using namespace std;

struct Point
{
	int x;
	int y;//这里的x、y分别用来表示横纵坐标
};

class Game
{
private:
	int x,y;
	clock_t t1,t2;//计时器
	int tt1,tt2;//时间间隔
	bool flag;//初始化炮台标志
	vector<Point>a;//炮弹容器
public:
	Game(int x0,int y0,int tt10,int tt20)
	{
		x=x0;y=y0;
		tt1=tt10;
		tt2=tt20;
		t1=clock();
		t2=clock();
		flag=true;//初始化炮台标志
	}
	//光标移动到指定坐标处
	void gotoxy(int x,int y)
	{
		HANDLE h;//句柄,对象的索引
		COORD c;//结构体,坐标值
		c.X=x;
		c.Y=y;
		h=GetStdHandle(STD_OUTPUT_HANDLE);
		SetConsoleCursorPosition(h,c);
	}
	bool key(int VK)
	{
		return GetAsyncKeyState(VK);
	}		
	void draw()
	{
		gotoxy(x,y);//gotoxy(int x, int y)是函数库 conio.h 中声明的一个函数，功能是将光标移动到指定位置。x和y分别代表的是横纵坐标
		cout<<"AA";
	}
	void erase()
	{
		gotoxy(x,y);
		cout<<"  ";
	}
	void move()
	{
		if(flag==true)
		{
			draw();
			flag=false;
		}
		if(clock()-t1>tt1)
		{
			if(key(VK_ESCAPE)) exit(0);
			if(key(VK_SPACE))
			{
				Point temp;
				temp.x=x  ;temp.y=y-1;
				a.push_back(temp);
			}
			if(key(VK_LEFT))
			{
				erase();
				--x;
				draw();
			}
			if(key(VK_RIGHT))
			{
				erase();
				++x;
				draw();
			}
			if(key(VK_UP))
			{
				erase();
				--y;
				draw();
			}
			if(key(VK_DOWN))
			{
				erase();
				++y;
				draw();
			}
			flag=true;
			t1=clock();
		}
	}
	void timer()//炮弹
	{
		if(clock()-t2>tt2)
		{
			for(int i=0;i<a.size();++i)
			{
				gotoxy(a[i].x,a[i].y);
				cout<<"  ";
				if(a[i].y>0)
				{
					--a[i].y;
					gotoxy(a[i].x,a[i].y);
					cout<<"♂";
				}
				else 
				{
					a.erase(a.begin()+i);//删除元素,括号中为地址
				}
			}
			//重新计时
			t2=clock();
		}
	}
};

int main()
{
	Game g(40,20,50,50);
//	g.draw();
	while(true)
	{
		g.move();
		g.timer();
	}
	return 0;
}


//数据库管理
#include <iostream>
#include <string>
#include <vector>
using namespace std;

struct A
{
	string name;
	string phone;
};

class B
{
private:
	vector <A> a;
	A temp;
public:
	B()
	{
		temp.name="1";temp.phone="111";a.push_back(temp);
		temp.name="2";temp.phone="222";a.push_back(temp);
		temp.name="3";temp.phone="333";a.push_back(temp);
		temp.name="3";temp.phone="555";a.push_back(temp);
	}
	void browse()
	{
		int i;
		cout<<"---------------------------"<<endl;
		for(i=0;i<a.size();++i)
		{
			cout<<i+1<<" "<<a[i].name<<"-"<<a[i].phone<<endl;
		}
		cout<<"---------------------------"<<endl;
	}
	void add()
	{
		while(true)
		{
			cout<<"input name(0-over):";cin>>temp.name;//0-over表示输入0结束
			if(temp.name=="0")break;
			cout<<"input phone:";cin>>temp.phone;
			a.push_back(temp);
		}
	}
	void find()//允许重名
	{
		string s;
		cout<<"input find name:";cin>>s;
		int i=0;
		bool flag=false;
		for(i=0;i<a.size();++i)
		{
			if(s==a[i].name)
			{
				cout<<a[i].name<<"-"<<a[i].phone<<endl;
				flag=true;
//				break;
			}
		}
		if(flag==false)
			cout<<"no this person!"<<endl;
	}
	void edit()
	{
		int m;
		browse();
		cout<<"input edit NO.:";cin>>m;
		if(m>0 && m<=a.size())
		{
			cout<<m<<" "<<a[m-1].name<<"-"<<a[m-1].phone<<endl;
			cout<<"---------------------------"<<endl;
			cout<<"input name:";cin>>a[m-1].name;
			cout<<"input phone:";cin>>a[m-1].phone;
			browse();
		}
	}
	void del()
	{
		int m;
		char c;
		browse();
		cout<<"input delete NO.:";cin>>m;
		if(m>0 && m<=a.size())
		{
			cout<<m<<" "<<a[m-1].name<<"-"<<a[m-1].phone<<endl;
			cout<<"---------------------------"<<endl;
			cout<<"delete(y/n)?:";cin>>c;
			if(c=='y')
				a.erase(a.begin()+m-1);
			browse();
		}
	}
};

int main()
{
	B b;
	b.find();
	return 0;
}

//英汉词典
#include <iostream>
#include <fstream>
#include <string>
#include <ctime>
#include <map>
using namespace std;
const int n=1000000;

class Dict
{
private:
	map<string,string>a;
	map<string,string>::iterator p;
public:
	Dict()
	{
		string s;
		ifstream f("英汉词典.txt",ios::in);//ifstream功能：文件读操作，存储设备读区到内存。其中ios::in 为输入(读)而打开文件
//如果想了解更多关于ifstream，则进入网址：https://blog.csdn.net/kingstar158/article/details/6859379/
		if(f)
		{
			while(true)
			{
				if(!f.eof())//这里的eof其实就是EOF
				{
					getline(f,s);//getline函数可读取整行，包括前导和嵌入的空格，并将其存储在字符串对象中。getline(cin, inputLine)
					a.insert(pair<string,string>(word1(s),word2(s)));//插入记录 
				}
				else break;
			}
			f.close();
		}
		else
		{
			cout<<"open file error!"<<endl;
			exit(0);
		}
	}
	//取出串中的英文单词－空格前面的部分
	string word1(string s)
	{
		int n;
		n=s.find(" ",0);
		return s.substr(0,n);
//		substr有2种用法：
//			假设：string s = "0123456789";
//		string sub1 = s.substr(5); //只有一个数字5表示从下标为5开始一直到结尾：sub1 = "56789"
//		string sub2 = s.substr(5, 3); //从下标为5开始截取长度为3位：sub2 = "567"
	}
	//取出串中的中文解释－空格后面的部分
	string word2(string s)
	{
		int n,pos;
		n=s.find(" ",0);
		pos=n;
		while(true)
		{
			if(s.substr(pos,1)!=" ")
			{
				n=pos;
				break;
			}
			else
				++pos;
		}
		return s.substr(n,s.size()-n);
	}
	void find_v()
	{
		clock_t t1,t2;
		string s1,s2;
		cout<<"input word:";cin>>s1;
		t1=clock();
		for(int i=0;i<n;++i)
		{
			p=a.find(s1);
		}
		if(p!=a.end())
			cout<<p->first<<"  "<<p->second<<endl;
		else
			s2="no word!";//没有这个单词 
		t2=clock();
		cout<<"time:"<<t2-t1<<endl;
	}	
};

int main()
{
	Dict d;
	d.find_v();
	return 0;
}
静！
关注
专栏目录
Docker（十七）：Docker Swarm（集群搭建） —实现容器编排的利器
✨ 欢迎来到【Seal ^_^ 的CSDN博客】！这里是我记录技术心得、分享经验的地方。✨
03-26 2万+
🟢 Docker（十七）：Docker Swarm（集群搭建） —实现容器编排的利器
docker学习之容器续
万里之书
03-05 435
docker
Docker续6：容器网络
最新发布
m0_70848838的博客
08-28 1447
新建两台主机：node1主控 192.168.1.78node2被控 192.168.1.79。
java持有对象【2】ArrayList容器续解
weixin_30692143的博客
07-05 49
此为JDK API1.6.0对ArrayList的解释。 ArrayList 使用java泛型创建类很复杂,但是应用预定义的泛型很简单。例如，要想定义用来保存Apple对象的ArrayList，可以声明ArrayList<Apple>,尖括号内为类型参数，（可以为多个）。它指定了容器可以保存的类型。 通过使用泛型，可以在编译期防止将错误类型的对象放置到容器中。 Arr...
ApplicationContext容器
YaoXTao的专栏
03-02 1036
ApplicationContext接口代表了一个Spring容器，它主要负责实例化、配置和组装bean。ApplicationContext接口间接继承了BeanFactory接口，相较于BeanFactory一些基本的容器功能，ApplicationContext接口是在BeanFactory接口基础上进行了扩展，增加了国际化、事件广播、获取资源等一些新的功能。refresh方法是Spring容器中一个非常核心的方法。经过refresh方法后，一个完整的Ioc容器已经创建完成。
Docker常用容器安装（续更中...）
weixin_44599955的博客
10-22 405
docker常用镜像与容器创建
docker 续 常用命令
weixin_70278423的博客
07-21 1336
ubuntu里的仓库文件使用不了的解决方法：1.进入仓库文件的目录2.删除 archive开头的文件3.重新下载仓库文件4.安装dockeraptapt-get 软件管理的命令 = centos里的yum/etc/apt/sources.list.d 等同于 /etc/yum.repos.d 都是用来存放仓库文件[root@docker ~]# docker exec -it sc-nginx-2 bash 进入一个容器内部。
虚拟机和容器的区别
weixin_41924879的博客
11-12 2703
虚拟机和容器的区别 虚拟机 虚拟机技术 虚拟化，是指通过虚拟化技术将一台计算机虚拟为多台逻辑计算机。在一台计算机上同时运行多个逻辑计算机，每个逻辑计算机可运行不同的操作系统，并且应用程序都可以在相互独立的空间内运行而互不影响，从而显著提高计算机的工作效率。 虚拟化是表示计算机资源的逻辑组（或子集）的过程，这样就可以用从原始配置中获益的方式访问它们。这种资源的新虚拟视图并不受实现、地理位置或...
nerdctl容器管理
识途老码
01-13 2636
nerdctl容器管理工具
matlab代码续行-algorithm_hub:基于容器的算法平台
05-26
代码续行 基于容器的算法平台 项目介绍 本项目旨在打造一个在线开发和协同编程的算法云平台。采用jupyter和容器来执行用户代码或算法，通过调度和监控将容器分布式部署和运行。 核心概念 项目：用户可以创建项目，...
容器生态系统 (续) - 每天5分钟玩转容器技术（3）
CloudMan6的博客
04-17 3919
容器生态系统包含核心技术、平台技术和支持技术三个方面。上一节我们讨论了核心技术，今天讨论另外两个部分。
7-7 验证“哥德巴赫猜想” (20 分)
weixin_50934744的博客
03-10 7611
7-7 验证“哥德巴赫猜想” (20 分) 数学领域著名的“哥德巴赫猜想”的大致意思是：任何一个大于2的偶数总能表示为两个素数之和。比如：24=5+19，其中5和19都是素数。本实验的任务是设计一个程序，验证20亿以内的偶数都可以分解成两个素数之和。 输入格式： 输入在一行中给出一个(2, 2 000 000 000]范围内的偶数N。 输出格式： 在一行中按照格式“N = p + q”输出N的素数分解，其中p ≤ q均为素数。又因为这样的分解不唯一（例如24还可以分解为7+17），要求必须输出所有解中p最小
7-7-2 找出总分最高的学生 (15 分)
weixin_50934744的博客
04-14 6256
7-7-2 找出总分最高的学生 (15 分) 给定N个学生的基本信息，包括学号（由5个数字组成的字符串）、姓名（长度小于10的不包含空白字符的非空字符串）和3门课程的成绩（[0,100]区间内的整数），要求输出总分最高学生的姓名、学号和总分。 输入格式： 输入在一行中给出正整数N（≤10）。随后N行，每行给出一位学生的信息，格式为“学号 姓名 成绩1 成绩2 成绩3”，中间以空格分隔。 输出格式： 在一行中输出总分最高学生的姓名、学号和总分，间隔一个空格。题目保证这样的学生是唯一的。 输入样例： 5 000
2-6-2 使用函数求最大公约数 (10 分)
weixin_50934744的博客
03-14 5699
2-6-2 使用函数求最大公约数 (10 分) 本题要求实现一个计算两个数的最大公约数的简单函数。 函数接口定义： int gcd( int x, int y ); 其中x和y是两个正整数，函数gcd应返回这两个数的最大公约数。 裁判测试程序样例： #include <stdio.h> int gcd( int x, int y ); int main() { int x, y; scanf("%d %d", &x, &y); printf("%d
7-7-1 查找书籍 (20 分)
weixin_50934744的博客
04-14 5646
7-7-1 查找书籍 (20 分) 给定n本书的名称和定价，本题要求编写程序，查找并输出其中定价最高和最低的书的名称和定价。 输入格式: 输入第一行给出正整数n（<10），随后给出n本书的信息。每本书在一行中给出书名，即长度不超过30的字符串，随后一行中给出正实数价格。题目保证没有同样价格的书。 输出格式: 在一行中按照“价格, 书名”的格式先后输出价格最高和最低的书。价格保留2位小数。 输入样例: 3 Programming in C 21.5 Programming in VB 18.5 Prog
10-6-8 有结构文件的读写1 (10 分)
weixin_50934744的博客
05-12 5362
10-6-8 有结构文件的读写1 (10 分) 学生类型：ST的类型定义如下： typedef struct student{ char name[10],id[10]; int gender; int age; double scored; } ST; 编写函数，从指定的文件上读入若干字符串，每行字符串是一个学生的信息（姓名，学号，性别，年龄，分数）的字符串表示，数据间以空格分隔，将学生们的信息存储于一个结构体中，并利用output()函数输出到指定文件中。 函数接口定义： void fun(FILE *
10-6-6 从文件读取字符串(*) (10 分)
weixin_50934744的博客
05-12 5256
10-6-6 从文件读取字符串(*) (10 分) 请编写函数，从文件中读取字符串。 函数原型 void FGetStr(char *str, int size, FILE *file); 说明：参数 str 为指示字符数组起始地址的指针，size 为数组尺寸，file 为文件指针。函数从文件输入的字符串(以换行符 ‘\n’ 结束)到字符数组中，并在字符末尾添加字符串结束标记 ‘\0’。显然，字符串的最大长度应为 size - 1，为字符串结束标记 ‘\0’ 预留空间。若用户输入的字符过多，则函数最多读取
3-7-1 去掉最大值和最小值 (10 分)
weixin_50934744的博客
03-25 4547
3-7-1 去掉最大值和最小值 (10 分) 申请一个10个单元的整型数组，输入10个整数，去掉一个最大值和一个最小值后，剩下的8个数求和 输入格式: 输入10个整数，空格分隔 输出格式: 去掉最大值和最小值后，求剩下8个数的和 输入样例: 在这里给出一组输入。例如： 2 1 1 1 1 1 1 1 1 0 输出样例: 在这里给出相应的输出。例如： 8 #include <stdio.h> int main() { int i,sum=0; int
续上
05-27
// 加密数据并保存到容器中 std::vector<seal::Ciphertext> encrypted_data; while (fgets(line, sizeof(line), fp)) { double longitude, latitude; sscanf(line, "%lf,%lf", &longitude, &latitude); seal:...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值