c++中级STR

最新推荐文章于 2024-05-20 15:29:54 发布
最新推荐文章于 2024-05-20 15:29:54 发布
阅读量405 收藏 9
点赞数 7
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62575733/article/details/135366152
版权

分享一些c++案例

str简介

//STL中容器，算法，迭代器
/*容器:置物之所也
STL容器就是将运用最广泛的一些数据结构实现出来
常用的数据结构:数组，链表，数，栈，队列，集合，映射表等
序列式容器和关联度容器
序列式容器:强调值的排序，序列式容器中每个元素均有固定的位置
关联式容器:二叉树结构，各元素之间没有严格的物理上的顺序关系
算法:问题之解法也
有限的步骤，解决逻辑或数学上的问题，这一门学科我们叫做算法
算法分为:质变算法或非质变算法。
质变算法:是指运算过程中会更改区间内的元素的内容。例如拷贝，替换
删除等等
非质变算法:是指运算过程中不会更改区间内的元素内容，例如查找，
计数，遍历，寻找极值等等
迭代器:容器和算法之间黏合剂
提供一种算法，使之能够依序寻访某个容器所含的各个元素，
而又无需暴露该容器的内部表达方式。
每个容器都有自己专属的迭代器
迭代器使用非常类似于指针，初学阶段我们可以先理解迭代器
为指针。
迭代器种类:
输入迭代器:对数据只读访问
输出迭代器:对数据只写访问
前向迭代器:读写操作，并能前向推进迭代器
双向迭代器:读写操作，并能向前和向后操作
随机访问迭代器:读写操作，可以以跳跃的方式访问任意数据，
功能最强迭代器。

容器算法迭代器初识

//容器算法迭代器初识
/*STL中最常用的容器为vector，可以理解为数组。
vector存放内置数据类型
容器:vector
算法:for_each
迭代器:vector<int>::iterator*/
#include <iostream>
using namespace std;
#include<vector>
#include<algorithm>//标准算法头文件
//victor容器存放内置数据类型
void myPrint(int val)
{
	cout<<val<<endl;
}
void test01()
{
	//创建了一个vector容器，数组
	vector<int>v;
	
	//向容器中插入数据
	v.push_back(10);
	v.push_back(20);
	v.push_back(30);
	v.push_back(40);
	
/*	//通过迭代器访问容器中的数据
	vector<int>::iterator itBegin=v.begin();//起始迭代器 指向容器中
	//第一个元素
	vector<int>::iterator itEnd=v.end();//结束迭代器 指向容器中最后
	//一个的下一个位置
	
//第一种遍历方式
	while (itBegin != itEnd)
	{
		cout<<*itBegin<<endl;
		itBegin++;
	}*/
/*	//第二种遍历方式
	for(vector<int>::iterator it =v.begin();it!=v.end();it++)
	{
		cout<<*it<<endl;
	}*/
//	第三种遍历方式 利用STL提供遍历算法
	for_each(v.begin(),v.end(),myPrint);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

容器中存放自定义类型

#include <iostream>
using namespace std;
#include<vector>
#include<string>
//vector容器中存放自定义数据类型
class Person
{
	public:
	Person(string name,int age)
	{
		this->m_Name=name;
		this->m_Age=age;
	}
	string m_Name;
	int m_Age;
};
void test01()
{
	vector<Person>v;
	Person p1("aaa",10);
	Person p2("bbb",20);
	Person p3("ccc",30);
	Person p4("ddd",40);
	Person p5("eee",50);
	//向容器中添加数据
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	v.push_back(p5);
	//遍历容器中的数据
	for(vector<Person>::iterator it=v.begin();it!=v.end();it++)
	{
	//	cout<<"姓名: "<<(*it).m_Name<<" 年龄"<<(*it).m_Age<<endl;
			cout<<"姓名: "<<it->m_Name<<" 年龄"<<it->m_Age<<endl;
	}
}
//存放自定义数据类型 指针
void test02()
{
	vector<Person*>v;
	Person p1("aaa",10);
	Person p2("bbb",20);
	Person p3("ccc",30);
	Person p4("ddd",40);
	Person p5("eee",50);
	//向容器中添加数据
	v.push_back(&p1);
	v.push_back(&p2);
	v.push_back(&p3);
	v.push_back(&p4);
	v.push_back(&p5);
	//遍历容器
	for(vector<Person*>::iterator it=v.begin();it!=v.end();it++)
	{
		cout<<"姓名:"<<(*it)->m_Name<<"年龄:"<<(*it)->m_Age<<endl;
	}
}
int main()
{
//	test01();
	test02();
	system("pause");
	return 0;
}

简单评委打分

/*有五名选手:选手ABCDE，10个评委分别对每一名选手打分
去除最高分，去除最低，取平均分
1.创建五名选手，放入vector容器中
2.遍历vector容器，取出来每一名选手，执行for循环，可以把十个评分
   打分存放到deque容器中
3.sort算法对deque容器中分数排序，去除最高和最低分
4.deque容器遍历一遍，累加总分
5.获取平均分*/
#include <iostream>
#include<vector>
#include<deque>
#include<string>
#include<algorithm>
using namespace std;
//选手类
class Person
{
	public:
	Person(string name,int score)
	{
		this->m_Name=name;
		this->m_Score=score;
	}
	string m_Name;
	int m_Score;
};
void creatPerson(vector<Person>&v)
{
			string nameSeed="ABCDE";
	for(int i=0;i<5;i++)
	{
		string name="选手";
		name+=nameSeed[i];
		int score=0;
		Person p(name,score);
		//将创建的person 对象 放入到容器中
		v.push_back(p);
	}
}
int main()
{
	//创建5名选手
	vector<Person>v;//存放选手容器
	creatPerson(v);
	//测试
	for(vector<Person>::iterator it=v.begin();it!=v.end();it++)
	{
		cout<<"姓名为"<<it->m_Name<<"分数为"<<it->m_Score<<endl;
	}
	//给5名选手打分
	
	//3.显示最后得分
	system("pause");
	return 0;
}

容器嵌套容器

#include <iostream>
using namespace std;
#include<vector>
//容器镶套容器
void test01()
{
	vector<vector<int>>v;
	//创建小容器
	vector<int>v1;
	vector<int>v2;
	vector<int>v3;
	vector<int>v4;
	//向小容器中添加数据
	for(int i=0;i<4;i++)
	{
		v1.push_back(i+1);
		v2.push_back(i+2);
		v3.push_back(i+3);
		v4.push_back(i+4);
	}
	//将小容器中插入到大容器中
	v.push_back(v1);
	v.push_back(v2);
	v.push_back(v3);
	v.push_back(v4);
	//通过大容器，把所有数据遍历一遍
	for(vector<vector<int>>::iterator it =v.begin();it != v.end();it++)
	{
		//(*it)---容器 vector<int>
		for(vector<int>::iterator vit=(*it).begin();vit!=(*it).end();vit++)
		{
			cout<<*vit<<" ";
		}
		cout<<endl;
	}
}
int main()
{
	test01();
	system("pause");
	return 0;
}

map容器的插入和删除

#include <iostream>
#include<vector>
#include<deque>
#include<string>
#include<algorithm>
#include<list>
#include<set>
#include<map>
#include<ctime>
using namespace std;
void printMap(map<int,int>&m)
{
	for(map<int,int>::iterator it=m.begin();it!=m.end();it++)
	{
		cout<<"key="<<it->first<<"value="<<it->second<<endl;
	}
	cout<<endl;
}
//map容器的插入和删除
void test01()
{
	map<int,int>m;
	//插入
	//第一种
	m.insert(pair<int,int>(1,10));
	//第二种
	m.insert(make_pair(2,20));
	//第三种
	m.insert(map<int,int>::value_type (3,30));
	//弟四种
	m[4]=40;
//	cout<<m[4]<<endl;
printMap(m);
//删除
m.erase(m.begin());
printMap(m);
m.erase(3);
printMap(m);
m.erase(m.begin(),m.end());
printMap(m);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

map容器的查找和统计

#include <iostream>
#include<vector>
#include<deque>
#include<string>
#include<algorithm>
#include<list>
#include<set>
#include<map>
#include<ctime>
using namespace std;
//map容器中的查找和统计
void test01()
{
	//查找
	map<int,int>m;
	m.insert(pair<int,int>(1,10));
	m.insert(make_pair(2,20));
	m.insert(pair<int,int>(3,30));
	m.insert(pair<int,int>(4,40));
	map<int,int>::iterator pos=m.find(3);
	if(pos!=m.end())
	{
		cout<<"查到了元素key="<<pos->first<<"value="<<(*pos).second<<endl;
	}
	else
	{
		cout<<"没有查找到"<<endl;
	}
	
	
	//统计
	int num=m.count(3);
	cout<<"num="<<num<<endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

容器排序

#include <iostream>
/*#include<vector>
#include<deque>
#include<string>
#include<algorithm>
#include<list>
#include<set>*/
#include<map>
//#include<ctime>
using namespace std;
class MyCompare
{
	public:
	bool operator()(int v1,int v2)
	{
		//降序
		return v1>v2;
	}
};
//map容器 排序
void test01()
{
	map<int,int,MyCompare>m;
	
	m.insert(make_pair(1,10));
	m.insert(make_pair(2,20));
	m.insert(make_pair(3,30));
	m.insert(make_pair(4,40));
	m.insert(make_pair(5,50));
	for(map<int,int,MyCompare>::iterator it=m.begin();it!=m.end();it++)
	{
		cout<<"key="<<it->first<<"value="<<it->second<<endl;
	}
}
int main()
{
	test01();
	system("pause");
	return 0;
}

string基本概念

/*  3.1.1  string基本概念
本质
string是c++风格的字符串，而string本质上是一个类
string 和char*区别
1.char*是一个指针
2.string 是一个类，类内部封装了char*,管理这个字符串，是一个
  char*型容器。
 特点
 string 类内部封装了很多成员方法
 如:查找find,拷贝copy,删除delect,替换replace,插入insert
 string 管理char*所分配的内存，不用担心复制越界和取值越界
 等，由类内部负责
 3.1.2 string构造函数
 构造函数原型
 string();创建一个空的字符串 例如:string str;
 string(const char*s);//使用字符串s初始化
 string(const string& str)//使用一个string对象初始化另一个
                 string 对象
 string(int n,char c) ;//使用n个字符c初始化*/
 #include <iostream>
using namespace std;
#include<string>
//string的构造函数
void test01()
{
	string s1;//默认构造;
	const char *str="hello world";
	string s2(str);
	cout<<"s2="<<s2<<endl;
	string s3(s2);
	cout<<"s3="<<s3<<endl;
	string s4(10,'a');
	cout<<"s4="<<s4<<endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

string赋值

/*3.1.3string 赋值操作
功能描述:
给string字符串进行赋值
赋值的函数原型
1.string& operator=(const char* s);//char*类型字符串 赋值给当前的
      字符串
2.string& operator=(const string &s);//把字符串s赋值给当前的字符串
3.string& operator=(char c);//字符赋值给当前的字符串
4.string& assign(const char*s);//把字符串s赋值给当前的字符串
5.string& assign(const char* s,int n);//把字符串s的前n个字符赋
       给当前的字符串
6.string& assign(const string &s);//把字符串s赋给当前字符串
7.string& assign(int n,char c);//用n个字符c赋给当前字符串*/
#include <iostream>
using namespace std;
#include<string>
void test01()
{
	string str1;
	str1="hello world";
	cout<<"str1="<<str1<<endl;
	string str2;
	str2=str1;
	cout<<"str2="<<str2<<endl;
	string str3;
	str3='a';
	cout<<"str3="<<str3<<endl;
	string str4;
	str4.assign("hello c++");
		cout<<"str4="<<str4<<endl;
	string str5;
	str5.assign("hello c++",5);
	cout<<"str5="<<str5<<endl;
	string str6;
	str6.assign(str5);
	cout<<"str6="<<str6<<endl;
	string str7;
	str7.assign(10,'w');
	cout<<"str7="<<str7<<endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

string字符串拼接

/* 3.1.4 string 字符串拼接
功能描述:
实现在字符串末尾拼接字符串
函数原型
1.string& operator+=(const char* str)//重载+=运算符
2.string& operator+=(const char c);//重载+=操作符
3.string& operator+=(const string& str);重载+=操作符
4.string& append(const char*s);//把字符串s链接到当前字符串
     结尾
5.string& append(const char*s,int n);//把字符串s的前n个字符
     连接到当前字符串结尾
6.string& append(const string &s);//同operator+=(const string& str)
7.string& append(const string &s,int pos,int n);
    //字符串s中从pos开始的n个字符连接到字符串结尾。*/
#include <iostream>
using namespace std;
#include<string>
void test01()
{
	string str1="我";
	str1+="爱玩游戏";
	cout<<"str1"<<str1<<endl;
	str1+=':';
	cout<<"str1"<<str1<<endl;
	string str2="LOL DNF";
	str1+=str2;
	cout<<"str1"<<str1<<endl;
	string str3="I";
	str3.append("love");
	cout<<"str3="<<str3<<endl;
	str3.append("game abcde",4);
	//i love game
	cout<<"str3="<<str3<<endl;
//	str3.append(str2);
//str3.append(str2,0,3);//只借去到lol
str3.append(str2,4,3);//只截取到DNF，参数2 从哪个位置开始截取
       //参数3 截取字符个数
	cout<<"str3="<<str3<<endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

string查找和转换

/*3.1.5 string 查找和转换
功能描述:
查找:查找指定字符串是否存在
替换:在指定位置替换字符串
函数原型:
1.int find(const string& str,int pos=0)const;
//查找str第一次出现位置，从pos开始查找
2.int find(const char* s,int pos =0)const;
//查找s第一次出现位置，从pos开始查找
3.int find(const char* s,int pos,int n)const;
//从pos位置查找s的前n个字符第一次位置
4.int find(const char c,int pos=0)const;
//查找字符串第一次出现位置
5.int rfind(const string& str,int pos=npos)const;
//查找str最后一次位置，从pos开始查找
6.int rfind(const char *s,int pos=npos)const;
//查找s最后一次出现位置，从pos开始查找
7.int rfind(const char *s,int pos,int n)const;
//从pos查找s的前个字符最后一次位置
8.string& replace(int pos,int n,const string& str);
//替换从pos开始n个字符为字符串str
9.string& replace(int pos,int n,const char* s);
//替换从pos开始n个字符为字符串s*/
#include <iostream>
using namespace std;
#include<string>
//字符串的查找和替换

//1.查找

void test01()
{
	string str1="abcdefgde";
	//0.1.2.3.4...
	int pos=str1.find("de");
	if(pos==-1)
	{
		cout<<"未找到字符串"<<endl;
	}
	else
	{
	cout<<"找到字符串，pos="<<pos<<endl;
	}
	//rfind
	pos=str1.rfind("de");
	cout<<"pos="<<pos<<endl;
	//rfind和find区别
	//rfind从右往左找，find从左往右找
}
//2.替换
void test02()
{
	string str1="abcdefg";
	//从一号位置起3个字符，替换为"1111";
	str1.replace(1,3,"1111");
	cout<<"str1="<<str1<<endl;
}
int main()
{
test01();
test02();
	system("pause");
	return 0;
}

string字符串比较

/*3.1.6string 字符串比较
功能描述:
字符串之间的比较
字符串比较是按字符的ASXLL码进行对比
=返回0
>返回1
<返回-1*/
#include <iostream>
using namespace std;
#include<string>
void test01()
{
	string str1="xello";
	string str2="hello";
	if(str1.compare(str2)==0)
	{
		cout<<"str1等于str2"<<endl;
	}
	else if(str1.compare(str2)>0)
	{
		cout<<"str1大于str2"<<endl;
	}
	else
	{
		cout<<"str1小于str2"<<endl;
	}
}
int main()
{
	test01();
	system("pause");
	return 0;
}

string字符存取

/*string 字符存取
string中单个字符存取方式有两种
1.char& operator[](int n)//通过[]方式取字符
2.char& at(int n);//通过at方法获取字符*/
#include <iostream>
using namespace std;
#include<string>
//string 字符存取
void test01()
{
	string str="hello";
	//cout<<"str="<<str<<endl;
	//1.通过[]访问单个字符
	for(int i=0;i<str.size();i++)
	{
		cout<<str[i]<<" ";
	}
	cout<<endl;
	//2.通过at方式访问单个字符
	for(int i=0;i<str.size();i++)
	{
		cout<<str.at(i)<<" ";
	}
	cout<<endl;
	//修改
	str[0]='x';
	//hello
	cout<<"str="<<str<<endl;
	str.at(1)='x';
	//xxllo
	cout<<"str="<<str<<endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

string的插入和删除

/*3.1.8string的插入与删除
功能描述
对string字符串进行插入和删除操作
函数原型
string& insert(int pos,const char* s);//插入字符串
string& insert(int pos,const string& str)//插入字符串
string& insert(int pos,int n,char c);//在指定位置插入n个字符c
string& erase(int pos,int n=npos);//删除从pos开始的n个字符*/
#include <iostream>
using namespace std;
#include<string>
//字符串 插入和删除
void test01()
{
	string str="hello";
	//插入
	str.insert(1,"111");
	cout<<"str="<<str<<endl;
	//删除
	str.erase(1,3);
	cout<<"str="<<str<<endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

string字串

/*3.1.9string 子串
功能描述
1.从字符串中获取想要的子串
函数原型
string substr(int pos=0,int n=npos)const;
//返回由pos开始的n个字符组成的字符串*/
#include <iostream>
using namespace std;
#include<string>
//string求子串
void test01()
{
	string str="abcdef";
	string subStr=str.substr(1,3);
	cout<<"subStr="<<subStr<<endl;
}
void test02()
{
	string email="zhangsan@sina.com";
	//从邮件的地址中 获取 用户名信息
	int pos=email.find("@");
	cout<<"pos="<<pos<<endl;
	//string usrName=email.substr(0,8);
		string usrName=email.substr(0,pos);
	cout<<usrName<<endl;
}
int main()
{
	test01();
	test02();
	system("pause");
	return 0;
}

vector赋值操作

/*3.2.3 vector赋值操作
功能描述
给vector容器进行赋值
函数原型
vector& operator=(const vector &vec);//重载等号操作符
2.assign(beg,end);//将[beg,end]区间中的数据拷贝赋值给本身
3.assign(n,elem);//将n个elem拷贝赋值给本身*/
#include <iostream>
using namespace std;
#include<vector>
void printVector(vector<int>& v)
{
	for(vector<int>::iterator it=v.begin();it!=v.end();it++)
	{
		cout<<*it<<" ";
	}
	cout<<endl;
}
//vector赋值
void test01()
{
	vector<int>v1;
	for(int i=0;i<10;i++)
	{
		v1.push_back(i);
	}
	printVector(v1);
	//赋值 operator=
	vector<int>v2;
	v2=v1;
	printVector(v2);
	//assign
	vector<int>v3;
	v3.assign(v1.begin(),v1.end());
	printVector(v3);
	//n个elem方式赋值
	vector<int>v4;
	v4.assign(10,100);
	printVector(v4);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

vector容量和大小

/*3.2.4 vector容量和大小
功能描述
1.对vector容器的容量和大小操作
函数原型
1.empty();//判断容器是否为空
2.capacity();//容器的容量
3.size();//返回容器中元素的个数
4.resize(int num);//重新指定容器的长度为num，
    若容器变长，则以默认值填充新位置。
    如果容器变短，则末尾超出容器长度的元素被删除。
5.resize(int num,elem);//重新指定容器的长度num，若容器
   变长则以elem值填充新位置。
   //如果容器变短，则末尾超出容器长度的元素被删除。*/
 #include <iostream>
using namespace std;
#include<vector>
void printVector(vector<int>& v)
{
	for(vector<int>::iterator it=v.begin();it!=v.end();it++)
	{
	cout<<*it<<" ";
	}
cout<<endl;
}
//vector容器的容量和大小操作
void test01()
{
	vector<int>v1;
	for(int i=0;i<10;i++)
	{
		v1.push_back(i);
	}
	printVector(v1);
	if(v1.empty())//为真，代表容器为空
	{
		cout<<"v1为空"<<endl;
	}
	else
		{
		cout<<"v1不为空"<<endl;
		cout<<"v1的容量为"<<v1.capacity()<<endl;
		cout<<"v1的大小为"<<v1.size()<<endl;
	}
	//重新指定大小
	//v1.resize(15);
	v1.resize(15,100);//利用重载版本，可以指定默认填充值，参数2
	printVector(v1);//如果重新指定的比原来要长，默认用o来填充。
v1.resize(5);
printVector(v1);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

vector插入和删除

/*3.2.5vector插入和删除
功能描述
对vector容器进行插入，删除，操作
函数原型
push_back(ele); //尾部插入元素ele
pop_back();//删除最后一个元素
insert(const_iterator pos,ele);//迭代器指向位置pos插入元素ele
insert(const_iterator pos);//删除迭代器指向的元素
erase(const_iterator start,const_iterator end);
   删除迭代器从start到end之间的元素
clear();删除容器中所有元素*/
#include <iostream>
using namespace std;
#include<string>
#include<vector>
void printVector(vector<int>& v)
{
	for(vector<int>::iterator it=v.begin();it!=v.end();it++)
{	cout<<*it<<" ";}
	cout<<endl;
}
//插入和删除
void test01()
{
	vector<int>v1;
	//尾插
	v1.push_back(10);
	v1.push_back(20);
	v1.push_back(30);
	v1.push_back(40);
	v1.push_back(50);
	//遍历
	printVector(v1);
		//尾删
		v1.pop_back();
		printVector(v1);
		//插入  第一个参数是迭代器
		v1.insert(v1.begin(),100);
		printVector(v1);
		
		v1.insert(v1.begin(),2,1000);
		printVector(v1);
		//删除
		v1.erase(v1.begin());
		printVector(v1);
		//清空
		//v1.erase(v1.begin(),v1.end());
		v1.clear();
		printVector(v1);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

vector数据存取

/*3.2.6vector数据存取
功能描述
对vector中的数据的存取操作
函数原型
at(int idx);//返回索引idx所指的数据
operator[]//返回索引idx所指的数据
front();返回容器中第一个元素数据
back();//返回容器中最后一个元素数据*/
#include <iostream>
#include<vector>
using namespace std;
//vector容器 数据存取
void test01()
{
	vector<int>v1;
	for(int i=0;i<10;i++)
	{
		v1.push_back(i);
	}
	//利用[]方式访问数值中的元素
	for(int i=0;i<v1.size();i++)
	{
		cout<<v1[i]<<" ";
	}
	cout<<endl;
	//利用at方式访问元素
	for(int i=0;i<v1.size();i++)
	{
		cout<<v1.at(i)<<" ";
	}
	cout<<endl;
	//获取第一个元素
	cout<<"获取第一个元素="<<v1.front()<<endl;
	cout<<"最后一个元素="<<v1.back()<<endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

vector互换容器

/*3.2.7vector互换容器
功能描述
实现两个容器内元素进行互换
函数原型
swap(vec);//将vec与本身的元素互换*/
#include <iostream>
#include<vector>
using namespace std;
void printVector(vector<int>&v)
{
	for(vector<int>::iterator it=v.begin();it!=v.end();it++)
	{
		cout<<*it<<" ";
	}
	cout<<endl;
}
//vector容器互换

//1.基本使用
void test01()
{
	vector<int>v1;
	for(int i=0;i<10;i++)
	{
		v1.push_back(i);
	}
	cout<<"交换前"<<endl;
	printVector(v1);
	vector<int>v2;
	for(int i=10;i>0;i--)
	{
		v2.push_back(i);
	}
	printVector(v2);
		cout<<"交换后"<<endl;
		v1.swap(v2);
		printVector(v1);
		printVector(v2);
}
//2.时机用途
//巧用swap可以收缩内存空间
void test02()
{
	vector<int>v;
	for(int i=0;i<100000;i++)
	{
		v.push_back(i);
	}
	//printVector(v);
	cout<<"v的容量为"<<v.capacity()<<endl;
	cout<<"v的大小为"<<v.size()<<endl;
	v.resize(3);//重新指定大小
	cout<<"v的容量为"<<v.capacity()<<endl;
	cout<<"v的大小为"<<v.size()<<endl;
	//巧用swap收缩内存
	vector<int>(v).swap(v);
	//vector<int>(v)   为匿名对象
		cout<<"v的容量为"<<v.capacity()<<endl;
	cout<<"v的大小为"<<v.size()<<endl;
	
}
int main()
{
	test01();
	test02();
	system("pause");
	return 0;
}

vector

/*3.2 vector 容器
功能
vector 数据结构和数组非常类似，也称为单端数组
vector与普通数组区别
1.而vector可以动态扩展
动态扩展
1.并不是在原空间后续接新空间，而是找更大的内存空间，
   然后将原数据拷贝新空间，释放原空间
 vector容器的迭代器是支持随机访问的迭代器
 3.2.2
 vector构造函数
 功能描述
 1.创建vector容器
 函数原型
 vector<T> v;//采用模板实现类实现，默认构造函数
 vector(v.begin(),v.end());//将v(begin(),end())区间中的元素拷贝给本身
 vector(n,elem);//构造函数将n个elem拷贝给本身
 vector(const vector &vec);//拷贝构造函数*/
#include <iostream>
using namespace std;
#include<string>
#include<vector>
void printVector(vector<int>&v)
{
	for(vector<int>::iterator it=v.begin();it!=v.end();it++)
	{
		cout<<*it<<" ";
	}
	cout<<endl;
}
//vector容器构造
void test01()
{
	vector<int>v1;//默认构造
	for(int i=0;i<10;i++)
	{
		v1.push_back(i);
	}
	printVector(v1);
	//通过区间的方式进行构造
	vector<int>v2(v1.begin(),v1.end());
	printVector(v2);
	//n个elem方式构造
	vector<int>v3(10,100);
	printVector(v3);
	//拷贝构造
	vector<int>v4(v3);
	printVector(v4);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

vector预留空间

/*3.2.8 vector预留空间
功能描述
减少vector在动态扩展容量时的扩展次数
函数原型
reserve(int len);//容器预留len个元素长度，预留位置不初始化
   元素不可访问
   */
#include <iostream>
#include<vector>
using namespace std;
//vector容器 预留空间
void test01()
{
	vector<int>v;
	//利用reserve预留空间
    v.reserve(0);
	int num=0;//统计开辟次数
	int *p=NULL;
	for(int i=0;i<100000;i++)
	{
		v.push_back(i);
		if(p!=&v[0])
		{
		  p=&v[0];
		  num++;
		}
	}
	cout<<"num="<<num<<endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

deque容器

/*3.3deque容器
3.3.1deque容器基本概念
功能:
双端数组，可以对头端进行插入删除操作
deque与vector区别
1.vector对于头部的插入删除效率低，数据量越大，效率越低
2.deque相对而言，对头部的插入删除速度回比vector快
vector访问元素时的速度会比deque快，这和两者内部实现有关*/
#include <iostream>
#include<vector>
#include<deque>
using namespace std;
void printDeque(const deque<int>&d)
{
	for(deque<int>::const_iterator it=d.begin();it!=d.end();it++)
	{
		//*it=100; 容器中的数据不可以修改了
		cout<<*it<<" ";
	}
	cout<<endl;
}
//deque 构造函数
void test01()
{
	deque<int>d1;
	for(int i=0;i<10;i++)
	{
		d1.push_back(i);
	}
	printDeque(d1);
	deque<int>d2(d1.begin(),d1.end());
	printDeque(d2);
	
	deque<int>d3(10,100);
	printDeque(d3);
	
	deque<int>d4(d3);
	printDeque(d4);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

deque赋值操作

/*3.3.3deque赋值操作
功能描述
给deque容器赋值
函数原型
deque& operator=(const deque &deq);//重载等号操作符
assign(beg,end);//将[beg,end]区间中的数据拷贝赋值给本身
saaign(n,elem);//将n个elem拷贝赋值给本身*/
#include <iostream>
#include<vector>
#include<deque>
using namespace std;
void printDeque(const deque<int>d)
{
	for(deque<int>::const_iterator it=d.begin();it!=d.end();it++)
	{
		cout<<*it<<" ";
	}
	cout<<endl;
}
//deque容器赋值操作
void test01()
{
	deque<int>d1;
	for(int i=0;i<10;i++)
	{
		d1.push_back(i);
	}
	printDeque(d1);
	//operator赋值
	deque<int>d2;
	d2=d1;
	printDeque(d2);
	
	deque<int>d3;
	d3.assign(d1.begin(),d1.end());
	printDeque(d3);
	
	deque<int>d4;
	d4.assign(10,100);
	printDeque(d4);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

deque大小操作

/*3.3.4deque大小操作
功能描述
对deque容器的大小操作
deque.empty();//判断容器是否为空
deque.size();//返回容器中元素的个数
deque.resize(num);//从新指定容器的长度为num，若容器变长
   则以默认填充新位置
   //如果容器变短，则末尾超出容器长度的元素被删除
deque.resize(num,elem);
         //从新指定容器的长度为num，若容器变长
        则以elem填充新位置
       //如果容器变短，则末尾超出容器长度的元素被删除*/
#include <iostream>
#include<vector>
#include<deque>
#include<string>
//deque容器大小操作
using namespace std;
void printDeque(const deque<int>&d)
{
	for(deque<int>::const_iterator it=d.begin();it!=d.end();it++)
	{
		cout<<*it<<" ";
	}
	cout<<endl;
}
void test01()
{
deque<int>d1;
for(int i=0;i<10;i++)
{
  d1.push_back(i);
}
printDeque(d1);
if(d1.empty())
{
	cout<<"d1为空"<<endl;
}
else
{
cout<<"d1不为空"<<endl;
cout<<"d1的大小为"<<d1.size()<<endl;
//deque没有容量概念
}
//从新指定大小
//d1.resize(15);
d1.resize(15,1);
printDeque(d1);

d1.resize(5);
printDeque(d1);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

deque容器的插入和删除

#include <iostream>
#include<vector>
#include<deque>
#include<string>
using namespace std;
void printDeque(const deque<int>&d)
{
	for(deque<int>::const_iterator it=d.begin();it!=d.end();it++)
	{
		cout<<*it<<" ";
	}
	cout<<endl;
}
//deque 容器的插入和删除

//两端操作
void test01()
{
    deque<int>d1;
    //尾插
    d1.push_back(10);
    d1.push_back(20);
    //头插
    d1.push_front(100);
    d1.push_front(200);
    printDeque(d1);
   //尾删
   d1.pop_back();
   printDeque(d1);
   //头删
   d1.pop_front();
   printDeque(d1);
}
void test02()
{
	deque<int>d1;
	d1.push_back(10);
	d1.push_back(20);
	d1.push_front(100);
	d1.push_front(200);
	
	printDeque(d1);
	//insert 插入
	d1.insert(d1.begin(),1000);
	printDeque(d1);
		d1.insert(d1.begin(),2,10000);
	printDeque(d1);
	//按照区间进行插入
	//10000 10000 1000 200,100 10 20
	deque<int>d2;
	d2.push_back(1);
	d2.push_back(2);
	d2.push_back(3);
	d1.insert(d1.begin(),d2.begin(),d2.end());
	printDeque(d1);
}
void test03()
{
		deque<int>d1;
	d1.push_back(10);
	d1.push_back(20);
	d1.push_front(100);
	d1.push_front(200);
	//删除
	deque<int>::iterator it=d1.begin();
	it++;
	d1.erase(it);
	//200,100,10,20
	printDeque(d1);
	//按照区间的方式删除
	d1.erase(d1.begin(),d1.end());
//	d1.clear();
//	printDeque(d1);
}
int main()
{
	//test01();
	test02();
//	test03();
	system("pause");
	return 0;
}

deque容器数据存取操作

#include <iostream>
#include<vector>
#include<deque>
#include<string>
using namespace std;
//deque容器数据存取操作
void test01()
{
  deque<int>d;
  d.push_back(10);
  d.push_back(20);
  d.push_back(30);
  d.push_front(100);
  d.push_front(200);
  d.push_front(300);
  //通过[]方式访问元素
  for(int i=0;i<d.size();i++)
  {
  	cout<<d[i]<<" ";
  }
  cout<<endl;
   for(int i=0;i<d.size();i++)
{
	cout<<d.at(i)<<" ";
}
cout<<endl;
cout<<"第一个元素为"<<d.front()<<endl;
cout<<"第二个元素为"<<d.back()<<endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

排序

#include <iostream>
#include<vector>
#include<deque>
#include<string>
#include<algorithm>
using namespace std;
void printDeque(const deque<int>&v)
{
	for(deque<int>::const_iterator it=v.begin();it!=v.end();it++)
	{
		cout<<*it<<" ";
	}
	cout<<endl;
}
void test01()
{
deque<int>d;
d.push_back(10);
d.push_back(20);
d.push_back(30);
d.push_front(100);
d.push_front(200);
d.push_front(300);
printDeque(d);
//300 200 100 10 20 30
//排序
sort(d.begin(),d.end());
cout<<"排序后"<<endl;
printDeque(d);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

list容器

#include <iostream>
#include<vector>
#include<deque>
#include<string>
#include<algorithm>
#include<list>
using namespace std;
void printList(const list<int>&L)
{
	for(list<int>::const_iterator it=L.begin();it!=L.end();it++)
	{
		cout<<*it<<" ";
	}
	cout<<endl;
}
void test01()
{
	//创建list容器
list<int>L1;//默认构造
//添加数据
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);
printList(L1);
//区间方式构造
list<int>L2(L1.begin(),L1.end());
printList(L2);
//拷贝构造
list<int>L3(L1);
printList(L3);
//n个elem
list<int>L4(10,1000);
printList(L4);
}
int main()
{
	test01();
	
	system("pause");
	return 0;
}

list容器的复制和交换

#include <iostream>
#include<vector>
#include<deque>
#include<string>
#include<algorithm>
#include<list>
using namespace std;
void printList(const list<int>&L)
{
	for(list<int>::const_iterator it=L.begin();it!=L.end();it++)
	{
		cout<<*it<<" ";
	}
	cout<<endl;
}
//list容器的复制和交换
void test01()
{
list<int>L1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);
printList(L1);
list<int>L2;
L2=L1;//operator= 赋值
printList(L2);
list<int>L3;
L3.assign(L2.begin(),L2.end());
printList(L3);
list<int>L4;
L4.assign(10,100);
printList(L4);
}
void test02()
{
	list<int>L1;
	L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);
list<int>L2;
L2.assign(10,100);
cout<<"交换前"<<endl;
printList(L1);
printList(L2);
L1.swap(L2);
cout<<"交换后"<<endl;
printList(L1);
printList(L2);
}
int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}

list容器大小操作

#include <iostream>
#include<vector>
#include<deque>
#include<string>
#include<algorithm>
#include<list>
using namespace std;
void printList(const list<int>&L)
{
	for(list<int>::const_iterator it=L.begin();it!=L.end();it++)
	{
		cout<<*it<<" ";
	}
	cout<<endl;
}
//list容器大小操作
void test01()
{
  list<int>L1;
  L1.push_back(10);
  L1.push_back(20);
  L1.push_back(30);
  L1.push_back(40);
  printList(L1);
  //判断容器是否为空
  if(L1.empty())
  {
  	cout<<"L1为空"<<endl;
  }
  else
  cout<<"L1不为空"<<endl;
  cout<<"L1的元素个数为:"<<L1.size()<<endl;
  //重新指定大小
  L1.resize(10,10000);
  printList(L1);
  L1.resize(2);
  printList(L1);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

list容器的插入和删除

#include <iostream>
#include<vector>
#include<deque>
#include<string>
#include<algorithm>
#include<list>
using namespace std;
void printList(const list<int>&L)
{
	for(list<int>::const_iterator it=L.begin();it!=L.end();it++)
	{
		cout<<*it<<" ";
	}
	cout<<endl;
}
//list容器的插入与删除
void test01()
{
   list<int>L;
   //尾插
   L.push_back(10);
   L.push_back(20);
   L.push_back(30);
   //头插
   L.push_front(100);
   L.push_front(200);
   L.push_front(300);
   printList(L);
   //尾删
   L.pop_back();
   printList(L);
   //头删
   L.pop_front();
   printList(L);
   //insert插入
   list<int>::iterator it=L.begin();
   L.insert(L.begin(),1000);
   printList(L);
   //删除
   it=L.begin();
   L.erase(++it);
   printList(L);
   //移除
   L.push_back(10000);
   L.push_back(10000);
   printList(L);
   //移除 移除掉一样的元素
   L.remove(10000);
   printList(L);
   //清空
   L.clear();
   printList(L);
}

int main()
{
	test01();
	system("pause");
	return 0;
}

list

#include <iostream>
#include<vector>
#include<deque>
#include<string>
#include<algorithm>
#include<list>
using namespace std;

void test01()
{
list<int>L1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);
//L1[0] 不可以用[]访问list容器中的元素
//L1.at(0) 不可以用at方式访问liat容器中的元素
//list本质是一个链表，不是用连续线性空间存储数据，
//迭代器也是不支持随机访问的
cout<<"第一个元素"<<L1.front()<<endl;
cout<<"最后一个元素为"<<L1.back()<<endl;
//验证迭代器是不支持随机访问的
list<int>::iterator it=L1.begin();
it++;
it--;
//it=it+1;不支持这种随机

}
int main()
{
	test01();
	system("pause");
	return 0;
}

list容器的反转与排序

#include <iostream>
#include<vector>
#include<deque>
#include<string>
#include<algorithm>
#include<list>
using namespace std;
void printList(list<int>&L)
{
	for(list<int>::iterator it=L.begin();it!=L.end();it++)
	{
		cout<<*it<<" ";
	}
	cout<<endl;
}
//list 容器反转和排序
void test01()
{
list<int>L1;
L1.push_back(20);
L1.push_back(10);
L1.push_back(50);
L1.push_back(40);
L1.push_back(30);
printList(L1);
//反转
L1.reverse();
cout<<"反转后"<<endl;
printList(L1);
}
bool myCompare(int v1,int v2)
{
	//降序 就让第一个数>第二个数
	return v1>v2;
}
	
//排序
void test02()
{
	list<int>L1;
	L1.push_back(20);
L1.push_back(10);
L1.push_back(50);
L1.push_back(40);
L1.push_back(30);
cout<<"排序前"<<endl;
printList(L1);
//所有不支持随机访问迭代器的容器，不可以用标准算法
//不支持随机访问迭代器的容器，内部会提供对应一些算法
//sort(L1.begin(),L1.end());
L1.sort();
cout<<"排序后"<<endl;
printList(L1);
L1.sort();
L1.sort(myCompare);
printList(L1);
}
int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}

set容器

//set/multiset容器
/*简介 所有元素都会在插入时自动被排序
set/multiset属于关联式容器，底层结构是用二叉树实现。
set不允许容器中有重复的元素。
multiset允许容器中有重复的元素
*/
#include <iostream>
#include<vector>
#include<deque>
#include<string>
#include<algorithm>
#include<list>
#include<set>
using namespace std;
//set容器的构造和赋值
void printSet(set<int>&s)
{
	for(set<int>::iterator it=s.begin();it!=s.end();it++)
	{
		cout<<*it<<" ";
	}
	cout<<endl;
}
void test01()
{
  set<int>s1;
  //插入数据 只有insert方式
  s1.insert(10);
  s1.insert(30);
  s1.insert(20);
  s1.insert(40);
  //遍历容器
  //set容器特点:所有元素在被插入时自动排序
  //set不允许插入重复值
  printSet(s1);
  //拷贝构造
  set<int>s2(s1);
  printSet(s2);
  //赋值
  set<int>s3;
  s3=s2;
  printSet(s3);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

set大小和交换

/*set 大小和交换
功能描述:
统计set容器大小以及交换set容器
函数原型
size();//返回容器中元素的数目
empty();//判断容器是否为空
swap();//交换两个集合容器
set不支持重新指定大小的*/
#include <iostream>
#include<vector>
#include<deque>
#include<string>
#include<algorithm>
#include<list>
#include<set>
using namespace std;
void printSet(set<int>&s)
{
	for(set<int>::iterator it=s.begin();it!=s.end();it++)
	{
		cout<<*it<<" ";
	}
	cout<<endl;
}
//set容器 大小和交换
void test01()
{
	set<int>s1;
	//插入数据
	s1.insert(10);
	s1.insert(20);
	s1.insert(30);
	s1.insert(50);
	//打印容器
   printSet(s1);
//判断是否为空
if(s1.empty())
{
	cout<<"s1为空"<<endl;
}
else
{
	cout<<"s1不为空"<<endl;
	cout<<s1.size()<<endl;
}
}
void test02()
{
		set<int>s1;
	//插入数据
	s1.insert(10);
	s1.insert(20);
	s1.insert(30);
	s1.insert(50);
		set<int>s2;
	//插入数据
	s2.insert(100);
	s2.insert(200);
	s2.insert(600);
	s2.insert(500);
	cout<<"交换前"<<endl;
	printSet(s1);
	printSet(s2);
	s1.swap(s2);
	cout<<"交换后"<<endl;
	printSet(s1);
    printSet(s2);
	
}
int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}

set容器插入和删除

#include <iostream>
#include<vector>
#include<deque>
#include<string>
#include<algorithm>
#include<list>
#include<set>
//set 容器 插入和删除
using namespace std;
void printSet(set<int>&s)
{
	for(set<int>::iterator it=s.begin();it!=s.end();it++)
	{
		cout<<*it<<" ";
	}
	cout<<endl;
}
void test01()
{
	set<int>s1;
	s1.insert(10);
	s1.insert(30);
	s1.insert(20);
	s1.insert(40);
    printSet(s1);
    //删除
    s1.erase(s1.begin());
    printSet(s1);
    s1.erase(30);
    printSet(s1);
    //s1.erase(s1.begin(),s1.end());
    s1.clear();
    printSet(s1);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

set容器查找和排序

#include <iostream>
#include<vector>
#include<deque>
#include<string>
#include<algorithm>
#include<list>
#include<set>
using namespace std;
//set容器的查找和统计
void test01()
{
	set<int>s1;
	s1.insert(10);
	s1.insert(30);
	s1.insert(20);
	s1.insert(40);
	set<int>::iterator pos=s1.find(30);
	if(pos!=s1.end())
	{
		cout<<"找到元素"<<endl;
	}
	else
	{
		cout<<"未找到"<<endl;
	}

}
void test02()
{
	set<int>s1;
	s1.insert(10);
	s1.insert(30);
	s1.insert(40);
	s1.insert(20);
	int num=s1.count(30);
	//对于set而言 统计结果 要么是0 要么是1
	cout<<"num="<<num<<endl;
}
int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}

pair对组创建

#include <iostream>
#include<vector>
#include<deque>
#include<string>
#include<algorithm>
#include<list>
#include<set>
using namespace std;
//pair对组的创建
void test01()
{
	//第一种方式
	pair<string,int>p("Tom",20);
	cout<<"姓名:"<<p.first<<"年龄"<<p.second<<endl;
	//第二种方式
	pair<string,int>p2=make_pair("jerry",30);
   cout<<"姓名:"<<p2.first<<"年龄"<<p2.second<<endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

容器排序

#include <iostream>
#include<vector>
#include<deque>
#include<string>
#include<algorithm>
#include<list>
#include<set>
using namespace std;
//容器排序
class MyCompare
{
	public:
	bool operator()(int v1,int v2)
	{
		return v1>v2;
	}
};
void test01()
{
	set<int>s1;
	s1.insert(10);
	s1.insert(30);
	s1.insert(20);
	s1.insert(40);
	s1.insert(50);
for(set<int>::iterator it=s1.begin();it!=s1.end();it++)
{
	cout<<*it<<" ";
}
cout<<endl;
//指定排序规则为从大到小
	set<int,MyCompare>s2;
	s2.insert(10);
	s2.insert(30);
	s2.insert(20);
	s2.insert(40);
	s2.insert(50);
for(set<int>::iterator it=s2.begin();it!=s2.end();it++)
{
	cout<<*it<<" ";
}
cout<<endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

set容器排序

#include <iostream>
#include<vector>
#include<deque>
#include<string>
#include<algorithm>
#include<list>
#include<set>
using namespace std;
//set容器排序，存放自定义数据类型
class Person
{
	public:
	Person(string name,int age)
	{
		this->m_Name=name;
		this->m_Age=age;
	}
	string m_Name;
	int m_Age;
};
class comparePerson
{
	public:
	bool operator()(const Person&p1,const Person&p2)
	{
		//按照年龄 降序
		return p1.m_Age>p2.m_Age;
	}
};
void test01()
{
	//自定义数据类型 都会指定排序规则
	set<Person,comparePerson>s;
	//创建Person对象
	Person p1("刘备",24);
	Person p2("关羽",28);
	Person p3("张飞",25);
	Person p4("赵云",21);
	s.insert(p1);
	s.insert(p2);
	s.insert(p3);
	s.insert(p4);
	for(set<Person,comparePerson>::iterator it=s.begin();it!=s.end();it++)
	{
		cout<<"姓名:"<<it->m_Name<<"年龄"<<it->m_Age<<endl;
	}
}
int main()
{
	test01();
	system("pause");
	return 0;
}

map容器

/*map容器
1.map中所有的元素都是pair
2.pair中第一个元素为key(键值),起到索引作用，第二个元素为
   value(实值)
3.所有元素都会根据元素的键值自动排序
本质
map/muliimap属于关联式容器，底层结构是二叉树实现。
优点 可以根据key值可以快速找到value值*/
#include <iostream>
#include<vector>
#include<deque>
#include<string>
#include<algorithm>
#include<list>
#include<set>
#include<map>
using namespace std;
void printMap(map<int,int>&m)
{
	for(map<int,int>::iterator it=m.begin();it!=m.end();it++)
	{
		cout<<"key="<<(*it).first<<"value="<<it->second<<endl;
	}
	cout<<endl;
}
//map容器 构造和赋值
void test01()
{
	//创建map容器
	map<int,int>m;
    m.insert(pair<int,int>(1,10));
    m.insert(pair<int,int>(3,20));
    m.insert(pair<int,int>(2,40));
    m.insert(pair<int,int>(4,30));
    printMap(m);
    //拷贝构造
    map<int,int>m2(m);
    printMap(m2);
    //赋值
    map<int,int>m3;
    m3=m2;
    printMap(m3);
}
int main()
{
	test01();
	return 0;
}

map容器操作

#include <iostream>
#include<vector>
#include<deque>
#include<string>
#include<algorithm>
#include<list>
#include<set>
#include<map>
#include<ctime>
using namespace std;
void printMap(map<int,int>&p)
{
	for(map<int,int>::iterator it=p.begin();it!=p.end();it++)
	{
		cout<<"key="<<it->first<<"value="<<it->second<<endl;
	}
}
//map容器 大小和交换操作
//大小
void test01()
{
	map<int,int>m;
	m.insert(pair<int,int>(1,10));
	m.insert(pair<int,int>(2,20));
	m.insert(pair<int,int>(3,30));
	if(m.empty())
	{
		cout<<"m为空"<<endl;
	}
	else
	{
		cout<<"m不为空"<<endl;
		cout<<"m的大小为"<<m.size()<<endl;
	}
}
void test02()
{
	map<int,int>m1;
	m1.insert(pair<int,int>(1,10));
	m1.insert(pair<int,int>(2,20));
	m1.insert(pair<int,int>(3,30));
	
	map<int,int>m2;
	m2.insert(pair<int,int>(4,100));
	m2.insert(pair<int,int>(5,200));
	m2.insert(pair<int,int>(6,300));
	cout<<"交换前"<<endl;
	printMap(m1);
	printMap(m2);
	m1.swap(m2);
	cout<<"交换后"<<endl;
	printMap(m1);
	printMap(m2);
}
int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}

set和multiset的区别

/* set和multiset区别
掌握set和multiset的区别
区别:set不可以插入重复数据，而multiset可以
set插入数据的同时会返回插入结果，表示插入是否成功
multiset不会检测数据，因此可以插入重复的数据*/
#include <iostream>
#include<vector>
#include<deque>
#include<string>
#include<algorithm>
#include<list>
#include<set>
using namespace std;
void test01()
{
	set<int>s;
	pair<set<int>::iterator ,bool> ret=s.insert(10);
	if(ret.second)
	{
		cout<<"第一次插入成功"<<endl;
	}
	else
	{
		cout<<"第一次插入失败"<<endl;
	}
	ret=s.insert(10);
		if(ret.second)
	{
		cout<<"第二次插入成功"<<endl;
	}
	else
	{
		cout<<"第二次插入失败"<<endl;
	}
	multiset<int>ms;
	//允许插入同一个值
	ms.insert(10);
	ms.insert(10);
	for(multiset<int>::iterator it=ms.begin();it!=ms.end();it++)
	{
		cout<<*it<<" ";
	}
	cout<<endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}
煎饼果子小鸢
关注
  • 7
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
华为内部C++中级培训教材
01-01
本华为内部的C++中级培训教材讲授C++语言的运用技术，包括：类、对象之间 的关系、对象的存储与布局、运算符重载、智能指针、仿函数、泛型编程， C++模式设计基本思想。
C++中级培训胶片.ppt
08-16
C++中级培训（华为） C++中级培训胶片.ppt
中级C++：异常
FamerSaul的博客
07-07 157
C语言传统的错误处理机制：C++：异常是一种处理错误的方式，当一个函数发现自己无法处理的错误时就可以抛出异常，让函数的直接或间接的调用者处理这个错误。**如果有一个块抛出一个异常，捕获异常的方法会使用 try 和 catch 关键字。try 块中放置可能抛出异常的代码，try 块中的代码被称为保护代码。**使用 try/catch 语句的语法如下所示： 异常处理使用 异常的抛出和匹配原则：在函数调用链中异常栈展开匹配原则： 异常的重新抛出： 异常安全、异常规范 构造函数完成对象的构造和初始化，最好不要在构
c++小游戏合集
热门推荐
蒟蒻の博客
08-08 3万+
下面是我从全网上找到的c++小游戏。3.c++打飞机小游戏。1.c++打怪小游戏。2.C++跑酷小游戏。4.c++扫雷小游戏。
c++中级贪吃蛇实现源码分享讲解
李小由的菜鸡博客
04-18 350
源码：（完整单文件可用，需要下载graphics.h，网有教程） #include<graphics.h>//图像库，需要单独下载 #include<iostream> #include "conio.h" //屏幕高宽和刷新常量 const int WID = 50; const int HEI = 30; const int BGC = WHITE; int x_box = NULL, y_box = NULL; using namespace std; //游戏维持类 clas
跟我学c++中级篇——正则表达式
fpcc的专栏
09-08 264
一、正则表达式 什么是正则表达式？这个东西非常简单理解，举一个例子，如果不小心把豆子、大米等多种粮食混合在了一起，现在又要分开。怎么办？最简单的方法是需要啥就一个个的捡出来。但是如果需要两种、三种…这时候儿可以动一下脑子，是不是可以用一个多层的筛子，每个筛子的网眼不同，那么不同的粮食就会自动的被过滤到指定的位置上。其实，正则的本质也是如此。只是实现的手段不同罢了，实现正则的方式一般有两种，一种是DFA（确定有限状态自动机）,一种是NFA（一种是非确定有限状态自动机），其实它们基本都是对树的遍历，有过编译原理
跟我学c++中级篇——初等字符串转化
fpcc的专栏
11-02 391
对c++17中提供的初等字符串的转换函数进行说明分析
跟我学C++中级篇——STL中的删除
fpcc的专栏
03-22 418
在STL中一般删除的方式有两类，一种是使用全局的std::remove(remove_if类似)，一种是使用容器自带的erase，前者其实并没有真正的删除数据，而后者则是在移动时，会有一些细节的处理，否则要么程序崩溃，要么达不到删除的目的。下面就这两个函数进行一下分析说明。在一些容器中也提供了remove（如std::list）方法,它和全局的std::remove还是用法区别不小的，这个大家需要自己看一下。注：C++20提供了std::erase这种更方便的用法。
C++ Primer 中级（11-20）
萝卜丝儿皮尔
03-05 409
析构函数 #include<iostream> #include<string> #include<vector> using namespace std; /* 如果类中有数据指针成员且构造函数中使用new初始化，那么必须自行写析构函数； 如果写了析构函数，那么一定要写复制构造函数和赋值函数。 */ class NoName { public: NoName() :pstring(new std::string), i(0), d(0) {} ~NoNam
中级C++：布隆过滤器
FamerSaul的博客
07-01 318
布隆过滤器的前世今生。 海量数据的处理。
中级C++：类型转换，IO流操作
FamerSaul的博客
07-11 589
前言 类型转换 IO流 内置类型的IO 自定义类型的IO 文件流IO stringstream
C++中级教材
12-07
中文版C++ primer版本，翻译通俗易懂，适合初级C++程序员的进阶学习文档，内容丰富翔实而不罗嗦，读起来有醍醐灌顶的顿悟，非常不错
C++中级编程
06-10
C++中级编程介绍，适合有一定基础的编程者学习。
C++中级课件
04-15
C++学习极佳的课件，深入浅出，抓住重点。
C语言之函数指针（持续更新）
最新发布
qq_47607743的博客
05-20 274
C语言指针
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 913
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
clang frontEnd插件 常见Traverse函数、Visit函数 例子
_
05-17 69
clang插件
C语言如何在链表中的指定位置插⼊结点？
PAP
05-15 263
C语言如何在链表中的指定位置插⼊结点？
C++中str转double
05-18
在C++中，可以使用stod()函数将字符串转换为double类型。该函数接受一个字符串参数，并返回一个double类型的值。 例如，假设有一个字符串变量str，表示一个double类型的数字，可以使用以下代码将其转换为double类型...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

煎饼果子小鸢

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值