C++学习笔记（二十一）-Toy模板网

这篇具有很好参考价值的文章主要介绍了C++学习笔记（二十一）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

一、set/multiset容器

1. set基本概念

简介：所有元素都会在插入时自动被排序

本质：set/multiset属于关联式容器，底层结构是用二叉树实现的

set和multiset的区别：set不允许容器中有重复的元素，multiset允许容器中有重复的元素

2. set构造和赋值

构造：

set<T> st; // 默认构造函数
set(const set &st); // 拷贝构造函数

赋值：

set& operator=(const set &st); // 重载等号操作符

#include <iostream>
#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;
}

void test01()
{
	set<int> s1;
	s1.insert(40);
	s1.insert(20);
	s1.insert(40);
	s1.insert(20);
	s1.insert(10);
	s1.insert(30);
	s1.insert(20);

	// 遍历容器
	// set容器特点：所有元素插入时自动被排序
	// set容器不允许插入重复值
	printSet(s1);

	// 拷贝构造
	set<int>s2(s1);
	printSet(s2);

	// 赋值
	set<int>s3;
	s3 = s2;
	printSet(s3);
}

int main(int argc, char* argv[])
{
	test01();
	return 0;
}

3. set大小和交换

函数原型：

size(); // 返回容器中元素的数目
empty(); // 判断容器是否为空
swap(st); // 交换两个集合容器

#include <iostream>
#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;
}

void test01()
{
	set<int> s1;
	s1.insert(40);
	s1.insert(20);
	s1.insert(40);
	s1.insert(20);
	s1.insert(10);
	s1.insert(30);
	s1.insert(20);

	// 判断是否为空
	if (s1.empty())
	{
		cout << "s1为空..." << endl;
	}
	else
	{
		cout << "s1不为空..." << endl;
		printSet(s1);
		cout << "s1的大小为:" << s1.size() << endl;
	}
	
	set<int>s2;
	s2.insert(1);
	s2.insert(3);
	s2.insert(5);
	s2.insert(7);
	s2.insert(9);
	
	// 交换前
	cout << "——交换前——" << endl;
	cout << "s1:";
	printSet(s1);
	cout << "s2:";
	printSet(s2);

	// 交换后
	s1.swap(s2);
	cout << "——交换后——" << endl;
	cout << "s1:";
	printSet(s1);
	cout << "s2";
	printSet(s2);
}

int main(int argc, char* argv[])
{
	test01();
	return 0;
}

4. set插入和删除

函数原型：

insert(elem); // 在容器中插入元素
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 it = s.begin(); it != s.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	set<int> s1;
	s1.insert(40);
	s1.insert(20);
	s1.insert(40);
	s1.insert(20);
	s1.insert(10);
	s1.insert(30);
	s1.insert(20);

	printSet(s1);

	// 删除
	s1.erase(++s1.begin());
	printSet(s1);

	s1.insert(20);
	s1.insert(50);
	printSet(s1);
	s1.erase(++s1.begin(), --s1.end());
	printSet(s1);

	s1.erase(50);
	printSet(s1);
	
	// 清空
	s1.insert(20);
	s1.insert(30);
	s1.clear();
	printSet(s1);
}

int main(int argc, char* argv[])
{
	test01();
	return 0;
}

5. set查找和统计

函数原型：

find(key); // 查找key是否存在，存在返回该键的元素的迭代器，不存在返回set.end()
count(key); // 统计key的元素个数

#include <iostream>
#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;
}

void test01()
{
	set<int> s1;
	s1.insert(40);
	s1.insert(20);
	s1.insert(40);
	s1.insert(20);
	s1.insert(10);
	s1.insert(30);
	s1.insert(20);

	printSet(s1);
	
	// 查找
	set<int>::iterator pos = s1.find(30);
	if (pos != s1.end())
	{
		cout << "找到元素:" << *pos << endl;
	}
	else
	{
		cout << "未找到该元素..." << endl;
	}

	// 统计
	// 对于set而言,统计结果要么为0要么为1
	cout << "30出现的次数为:" << s1.count(30) << endl;
}

int main(int argc, char* argv[])
{
	test01();
	return 0;
}

6. set和multiset区别

set不可以插入重复数据，而multiset可以
set插入数据的同时会返回插入结果，表示插入是否成功
multiset不会检测数据，因此可以插入重复数据

#include <iostream>
#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;
}

void printMultiset(multiset<int>& ms)
{
	for (multiset<int>::iterator it = ms.begin(); it != ms.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	set<int> s1;
	pair<set<int>::iterator,bool> ret = s1.insert(10);
	if (ret.second)
	{
		cout << "第一次插入成功..." << endl;
	}
	else
	{
		cout << "第一次插入失败..." << endl;
	}

	ret = s1.insert(10);
	if (ret.second)
	{
		cout << "第二次插入成功..." << endl;
	}
	else
	{
		cout << "第二次插入失败..." << endl;
	}
	cout << "set为:";
	printSet(s1);

	multiset<int> ms1;
	ms1.insert(10);
	ms1.insert(10);
	cout << "multiset为:";
	printMultiset(ms1);
}

int main(int argc, char* argv[])
{
	test01();
	return 0;
}

7. pair对组创建

成对出现的数据，利用对组可以返回两个数据

两种创建方式：

pair<type, type> p (value1, value2);
pair<type, type> p = make_pair(value1, value2);

#include <iostream>
#include <set>

using namespace std;

void test01()
{
	// 对组创建
	// 1. 第一种方式
	pair<string, int>p1("Tom", 20);
	cout << "姓名:" << p1.first << " " << "年龄:" << p1.second << endl;
	
	// 第二种方式
	pair<string, int>p2 = make_pair("Jerry", 30);
	cout << "姓名:" << p2.first << " " << "年龄:" << p2.second << endl;
}

int main(int argc, char* argv[])
{
	test01();
	return 0;
}

8. set排序

问题：set容器默认排序规则为从小到大，如何改变排序规则？

主要技术点：利用仿函数，可以改变排序规则

1）set存放内置数据类型

#include <iostream>
#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;
}

class myCompare
{
public:
	bool operator()(int num1, int num2)const
	{
		return num1 > num2;
	}
};

void printMyset(set<int, myCompare>& ms)
{
	for (set<int,myCompare>::iterator it = ms.begin(); it != ms.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	set<int>s1;
	s1.insert(40);
	s1.insert(20);
	s1.insert(50);
	s1.insert(10);
	s1.insert(30);

	cout << "s1为:";
	printSet(s1);

	// 指定排序规则为从大到小
	set<int, myCompare>s2;
	s2.insert(40);
	s2.insert(20);
	s2.insert(50);
	s2.insert(10);
	s2.insert(30);
	cout << "s2为:";
	printMyset(s2);
}

int main(int argc, char* argv[])
{
	test01();
	return 0;
}

2）set存放自定义数据类型

#include <iostream>
#include <set>
#include <string>

using namespace std;

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)const
	{
		return p1.m_Age > p2.m_Age;
	}
};

void test01()
{
	// 自定义数据类型都会指定排序规则
	set<Person, comparePerson>s1;

	// 创建Person对象
	Person p1("刘备", 40);
	Person p2("关羽", 30);
	Person p3("张飞", 25);
	Person p4("赵云", 20);
	s1.insert(p1);
	s1.insert(p2);
	s1.insert(p3);
	s1.insert(p4);

	for (set<Person, comparePerson>::iterator it = s1.begin(); it != s1.end(); it++)
	{
		cout << "姓名:" << (*it).m_Name << " " << "年龄:" << (*it).m_Age << endl;
	}
	// 指定排序规则为从大到小
	
}

int main(int argc, char* argv[])
{
	test01();
	return 0;
}

总结：对于自定义数据类型，set必须指定排序规则才可以插入数据

二、map/multimap容器

1. map基本概念

简介：

map中所有元素都是pair
pair中第一个元素为key（键值），起到索引作用，第二个元素为value（实值）
所有元素都会根据元素的键值自动排序

本质：

map/multimap属于关联式容器，底层结构是用二叉树实现的

优点：

可以根据key值快速找到value值

map和multimap区别：

map不允许容器中有重复key值元素
multimap允许容器中有重复key值元素

2. map构造和赋值

函数原型：

map<T1, T2> mp; // map默认构造函数
map(const map &mp); // 拷贝构造函数

赋值：

map& operator=(const map &mp); // 重载等号操作符

#include <iostream>
#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;
}

void test01()
{
	// 创建map容器
	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));
	m1.insert(pair<int, int>(4, 40));
	m1.insert(pair<int, int>(5, 50));

	printMap(m1);

	// 拷贝构造
	map<int, int>m2(m1);
	printMap(m2);

	// 赋值
	map<int, int>m3;
	m3 = m2;
	printMap(m3);
}

int main(int argc, char* argv[])
{
	test01();
	return 0;
}

3. map大小和交换

函数原型：

size(); // 返回容器中元素的数目
empty(); // 判断容器是否为空
swap(st); // 交换两个map容器

#include <iostream>
#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;
}

void test01()
{
	// 创建map容器
	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));
	m1.insert(pair<int, int>(4, 40));
	m1.insert(pair<int, int>(5, 50));

	// 判断map是否为空
	if (m1.empty())
	{
		cout << "m1为空..." << endl;
	}
	else
	{
		cout << "m1不为空..." << endl;
		printMap(m1);
		cout << "m1的大小为:" << m1.size() << endl;
	}

	map<int, int>m2;
	m2.insert(pair<int, int>(6, 10));
	m2.insert(pair<int, int>(7, 10));
	m2.insert(pair<int, int>(8, 10));
	m2.insert(pair<int, int>(9, 10));
	m2.insert(pair<int, int>(10, 10));

	// 交换前
	cout << "————交换前————" << endl;
	cout << "m1:" << endl;
	printMap(m1);
	cout << "m2:" << endl;
	printMap(m2);

	// 交换后
	m1.swap(m2);
	cout << "————交换后————" << endl;
	cout << "m1:" << endl;
	printMap(m1);
	cout << "m2:" << endl;
	printMap(m2);
}

int main(int argc, char* argv[])
{
	test01();
	return 0;
}

4. map插入和删除

函数原型：

insert(elem); // 在容器中插入元素
clear(); // 清楚所有元素
erase(pos); // 删除pos迭代器所指的元素，返回下一个元素的迭代器
erase(beg, end); // 删除区间[beg, end)的所有元素，返回下一个元素的迭代器
erase(key); // 删除容器中值为key的元素

#include <iostream>
#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;
}

void test01()
{
	// 创建map容器
	map<int, int>m1;
	// 第一种
	m1.insert(pair<int, int>(1, 10));
	// 第二种
	m1.insert(make_pair(2, 20));
	// 第三种
	m1.insert(map<int, int>::value_type(3, 30));
	// 第四种
	m1[4] = 40;
	
	// []不建议使用,如果key值不存在,会创建一个valua为0的键值对
	// []用途可以利用key访问value
	cout << m1[100] << endl;
	m1[100] = 100;
	cout << m1[100] << endl;
	printMap(m1);
	
	// 删除
	m1.erase(m1.begin());
	printMap(m1);
	m1.erase(++m1.begin(), --m1.end());
	printMap(m1);
	m1.erase(100);
	printMap(m1);

	// 清空
	m1.clear();
}

int main(int argc, char* argv[])
{
	test01();
	return 0;
}

5. map查找和统计

函数原型：

find(key); // 查找key是否存在，若存在，返回该键元素的迭代器，若不存在，返回map.end()
count(key); // 统计key的元素个数

#include <iostream>
#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;
}

void test01()
{
	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));
	m1.insert(pair<int, int>(4, 40));

	map<int, int>::iterator pos = m1.find(3);

	if (pos != m1.end())
	{
		cout << "查找到key对应的value值为:" << (*pos).second << endl;
	}
	else
	{
		cout << "未查找到该元素..." << endl;
	}

	// 统计
	// map不允许插入重复的key元素,count对于map来说,结果要么为0要么为1
	int num = m1.count(30);
	cout << "num = " << num << endl;
}

int main(int argc, char* argv[])
{
	test01();
	return 0;
}

6. map排序

#include <iostream>
#include <map>

using namespace std;

class myCompare
{
public:
	bool operator()(int num1, int num2) const
	{
		return num1 > num2;
	}
};

void printMap(map<int, int, myCompare>& m)
{
	for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
	{
		cout << "key:" << (*it).first << " " << "value:" << (*it).second << endl;
	}
	cout << endl;
}

void test01()
{
	map<int, int, myCompare>m1;
	m1.insert(pair<int, int>(1, 10));
	m1.insert(pair<int, int>(2, 20));
	m1.insert(pair<int, int>(3, 30));
	m1.insert(pair<int, int>(4, 40));

	printMap(m1);
}

int main(int argc, char* argv[])
{
	test01();
	return 0;
}

三、STL案例

1. 案例描述

1）公司招聘了10个员工（ABCDEFGHIJ），10名员工进入公司之后，需要指派员工在哪个部门工作

2）员工信息有：姓名，工资组成

3）部门分为：策划，美术，研发

4）随机给10名员工分配部门和工资

5）通过multimap进行信息的插入 key(部门编号) value(员工)

2. 实现步骤

1）创建10名员工，放在vector中

2）便利vector容器，取出每个员工，进行随机分组

3）分组后，将员工部门编号作为key，具体员工作为value，放入multimap容器中

4）分部门显示员工信息文章来源地址https://www.toymoban.com/news/detail-802270.html

3. 代码实现

#include <iostream>
#include <string>
#include <map>
#include <vector>
#include <ctime>

using namespace std;

#define CEHUA 0
#define MEISHU 1
#define YANFA 2

class Worker
{
public:
	string m_Name;
	int m_Salary;
};

void creatWorker(vector<Worker>&v)
{
	string nameSeed = "ABCDEFGHIJ";
	for (int i = 0; i < 10; i++)
	{
		Worker worker;
		worker.m_Name = "员工";
		worker.m_Name += nameSeed[i];
		worker.m_Salary = rand() % 10001 + 10000;

		// 将员工放入到容器中
		v.push_back(worker);
	}
}

void setGroup(vector<Worker>& v, multimap<int, Worker>& m)
{
	for (vector<Worker>::iterator it = v.begin(); it != v.end(); it++)
	{
		// 产生随机部分编号
		int deptId = rand() % 3;

		// 把员工插入到分组中
		// key为部门编号,value为具体员工
		m.insert(make_pair(deptId, *it));
	}
}

void showWorkerByGroup(multimap<int, Worker>& m)
{
	cout << "策划部门:" << endl;
	multimap<int,Worker>::iterator pos = m.find(CEHUA);
	int count = m.count(CEHUA); // 统计具体人数
	int index = 0;
	for (; pos != m.end() && index < count; pos++, index++)
	{
		cout << "姓名:" << pos->second.m_Name << " " << "工资:" << pos->second.m_Salary << endl;
	}

	cout << "美术部门:" << endl;
	pos = m.find(MEISHU);
	count = m.count(MEISHU); // 统计具体人数
	index = 0;
	for (; pos != m.end() && index < count; pos++, index++)
	{
		cout << "姓名:" << pos->second.m_Name << " " << "工资:" << pos->second.m_Salary << endl;
	}

	cout << "研发部门:" << endl;
	pos = m.find(YANFA);
	count = m.count(YANFA); // 统计具体人数
	index = 0;
	for (; pos != m.end() && index < count; pos++, index++)
	{
		cout << "姓名:" << pos->second.m_Name << " " << "工资:" << pos->second.m_Salary << endl;
	}
}

void test01()
{
	srand((unsigned int)time(NULL));

	// 1.创建员工
	vector<Worker>worker;
	creatWorker(worker);

	 测试
	//for (vector<Worker>::iterator it = worker.begin(); it != worker.end(); it++)
	//{
	//	cout << "姓名:" << it->m_Name << " " << "工资:" << it->m_Salary << endl;
	//}

	// 2.分组
	multimap<int, Worker>group;
	setGroup(worker, group);

	// 3.分组显示员工
	showWorkerByGroup(group);
}

int main(int argc, char* argv[])
{
	test01();
	return 0;
}

到了这里，关于C++学习笔记（二十一）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！