目录
●set构造和赋值
●set大小和交换
●set插入和删除
●set查找和统计
●set排序（改变其排序规则，仿函数的运用）
●set和multiset
1.对组（pair）的创建
2.set的验证（不可以重复插入数据）
3.multiset的验证（可以重复插入数据）
●set构造和赋值
函数原型：
1.构造
■set<T> st //默认构造函数
■set(const set &st) //拷贝构造函数
2. 赋值
■set& operator=(const set &st) //重载等号操作符
#include<iostream>
#include<set>
using namespace std;
void printset(set<int>&s)
{
for (set<int>::iterator i = s.begin(); i != s.end(); i++)
{
cout << *i<<" ";
}
cout << endl;
}
void text()
{
//set容器：在所有元素插入的时候自动被被升序排序，该容器不允许插入重复值
set<int>s;
//默认构造
for (int i = 10; i >= 1; i--)
{
s.insert(i); //插入数据只有insert
}
//拷贝构造
set<int>s1(s);
printset(s1);
//赋值
set<int>s2;
s2 = s;
printset(s1);
}
int main()
{
text();
}
●set大小和交换
函数原型：
1.大小
■size() //返回容器中元素的数目
■empty() //判断容器是否为空
2.交换
■swap(st) //交换两个集合容器
#include<iostream>
#include<set>
using namespace std;
void printset(set<int>&s)
{
for (set<int>::iterator i = s.begin(); i != s.end(); i++)
{
cout << *i<<" ";
}
cout << endl;
}
void size(set<int>& s)
{
cout<<"s的大小为："<<s.size()<<endl;
}
void isempty(set<int>&s)
{
if (s.empty()) {
cout << "s为空" << endl;
}
else {
cout << "s不为空" << endl;
size(s);
}
}
void swap(set<int>& s1, set<int>& s2)
{
cout << "交换前：" << endl;
printset(s1);
printset(s2);
cout << "交换后：" << endl;
s1.swap(s2);
printset(s1);
printset(s2);
}
void text()
{
set<int>s;
s.insert(45);
s.insert(12);
s.insert(99);
s.insert(67);
s.insert(10);
printset(s);
//判断是否为空并且输出大小为多少
isempty(s);
//交换
set<int>s1;
s1.insert(1);
s1.insert(2);
s1.insert(3);
set<int>s2;
s2.insert(4);
s2.insert(5);
s2.insert(6);
swap(s1,s2);
}
int main()
{
text();
}
●set插入和删除
函数原型：
1.插入
■insert(elem); //在容器中插入元素
2.删除
■clear() //清除所有元素
■erase(pos) //删除pos迭代器所指的元素，返回下一个元素的迭代器
■erase(beg，end) //删除区间[beg,end)的所有元素，返回下一个元素的迭代器
■erase(elem) //删除容器中值为elem的元素
#include<iostream>
#include<set>
using namespace std;
void printset(set<int>&s)
{
for (set<int>::iterator i = s.begin(); i != s.end(); i++)
{
cout << *i<<" ";
}
cout << endl;
}
void text()
{
set<int>s;
for (int i = 10; i >= 1; i--)
{
s.insert(i);
}
printset(s); //1 2 3 4 5 6 7 8 9 10
//删除
s.erase(s.begin());
printset(s); //2 3 4 5 6 7 8 9 10
s.erase(3);
s.erase(5);
s.erase(7);
s.erase(9);
printset(s); //2 4 6 8 10
//清空
//s.erase(s.begin(), s.end());
s.clear();
printset(s);
}
int main()
{
text();
}
●set查找和统计
函数原型：
1.查找
■find(key) //查找key是否存在,若存在，返回该键的元素的迭代器;若不存在，返回set.end()
2.统计
■count(key) //统计key的元素个数
#include<iostream>
#include<set>
using namespace std;
void find(set<int>&s)
{
cout << "请输入在set容器中要查找的数：";
int n; cin >> n;
set<int>::iterator i = s.find(n);
if (i != s.end()) {
cout << "找到元素：" << *i << endl;
}
else {
cout << "未找到元素" << endl;
}
}
void count(set<int>& s)
{
cout << "请输入在set容器中要统计的数：";
int n; cin>>n;
//由于set容器不允许插入重复值，所以最终个数的结果要么1，要么0
cout << "在set容器中该数的个数："<<s.count(n) << endl;
}
void text()
{
set<int>s;
s.insert(10);
s.insert(20);
s.insert(20);
s.insert(30);
s.insert(40);
//查找指定元素
find(s);
//统计指定元素
count(s);
}
int main()
{
text();
}
●set排序（改变其排序规则，仿函数的运用）
1.内置数据类型
#include<iostream>
#include<set>
using namespace std;
class compare {
public:
bool operator()(int s1,int s2) const //布尔bool+重载operator()+set的模板参数列表(int s1,int s2)+const
{
return s1 > s2;
}
};
void printset_1(set<int>&s1)
{
for (set<int>::iterator i = s1.begin(); i != s1.end(); i++)
{
cout << *i<<" ";
}
cout << endl;
}
void printset_2(set<int,compare>&s2)
{
for (set<int,compare>::iterator i = s2.begin(); i != s2.end(); i++)
{
cout << *i << " ";
}
cout << endl;
}
void text()
{
//按set初始状态从小到大排序
set<int>s1;
s1.insert(45);
s1.insert(12);
s1.insert(99);
s1.insert(67);
s1.insert(10);
printset_1(s1);
//将set排序的规则改为从大到小
set<int, compare>s2;
s2.insert(45);
s2.insert(12);
s2.insert(99);
s2.insert(67);
s2.insert(10);
printset_2(s2);
}
int main()
{
text();
}
2.自定义数据类型
#include<iostream>
#include<string>
#include<set>
using namespace std;
class person {
public:
person(string name,string sex,int age)
{
this->name=name;
this->sex = sex;
this->age = age;
}
string name;
string sex;
int age;
};
class compare {
public:
bool operator()( person p_1, person p_2)const
{
return p_1.age > p_2.age;
}
};
void printset(set<person, compare>&s)
{
for (set<person, compare>::iterator i = s.begin(); i != s.end(); i++)
{
cout << "姓名：" << i->name <<" " << "性别：" << i->sex<<" " << "年龄：" << i->age << endl;
}
}
void text()
{
set<person,compare>s;
person p1("张三","男",34); s.insert(p1);
person p2("李四", "男", 14); s.insert(p2);
person p3("王五", "男", 24); s.insert(p3);
person p4("赵六", "男", 18); s.insert(p4);
person p5("孙七", "男", 16); s.insert(p5);
printset(s);
}
int main()
{
text();
}
●set和multiset
区别：
1.set不可以插入重复数据，而multiset可以；
2.set插入数据的同时会返回插入结果，表示插入是否成功；
3.multiset不会检测数据，因此可以插入重复数据；
1.对组（pair）的创建
简要介绍：成对出现的数据，利用对组可以返回两个数据
创建方式：
■pair<type, type> p ( value1, value2 );
■pair<type, type> p = make pair( value1, value2 );
#include<iostream>
#include<string>
using namespace std;
void text()
{
pair<string, int>p1("zhangsan", 20);
cout << "姓名：" << p1.first << " " << "年龄：" << p1.second << endl;
pair<string, int>p2 = make_pair("lisi", 21);
cout << "姓名：" << p2.first<< " " << "年龄：" << p2.second << endl;
}
int main()
{
text();
}
2.set的验证（不可以重复插入数据）
转到insert定义查看其底层代码，可知其底层为pair对组，所以我们想要去验证set的不可以重复插入数据，就需要用pair对组去验证。
#include<iostream>
#include<set>
using namespace std;
void judge(pair<set<int>::iterator, bool>&record)
{
if (record.second) {
cout << "插入成功" << endl;
}
else {
cout << "插入失败" << endl;
}
}
void text()
{
set<int>s;
//采用pair对组去观察第一次插入和第二次插入的bool值，也就是判断 record.second 的值从而验证set容器不能插入重复值
pair<set<int>::iterator, bool>record;
cout << "第一次插入" << endl;
record = s.insert(10);
judge(record);
cout << "第二次插入" << endl;
record = s.insert(10);
judge(record);
}
int main()
{
text();
}
3.multiset的验证（可以重复插入数据）
转到insert定义查看其底层代码，可知其底层为一个迭代器。迭代器不会去判断插入是否成功与失败，所以multiset可以重复的去插入你所指定类型的数据。
#include<iostream>
#include<set>
using namespace std;
void text()
{
multiset<int>ms;
//允许插入重复数据
ms.insert(10);
ms.insert(10);
ms.insert(10);
for (multiset<int>::iterator i = ms.begin(); i != ms.end(); i++)
{
cout << *i << " ";
}
cout << endl;
}
int main()
{
text();
}
