容器（续）

最新推荐文章于 2024-08-28 17:47:34 发布

静！

最新推荐文章于 2024-08-28 17:47:34 发布

阅读量84

点赞数

分类专栏： c++ c语言

本文链接：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;
}