C++从入门到精通 第十四章（STL容器）【下】

七、list容器

1、list的基本概念

（1）list的功能是将数据进行链式存储，对应数据结构中的链表，链表是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的。

（2）链表由一系列结点组成，结点用结构体实现，其中的成员一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。

（3）STL中的链表是一个双向循环链表。

（4）由于链表的存储方式并不是连续的内存空间，因此链表中的迭代器只支持前移和后移，属于双向迭代器。

（5）list的优缺点：

①list的优点：采用动态存储分配，不会造成内存浪费和溢出；链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素。

②list的缺点：链表灵活，但是空间（指针域）和时间（遍历）额外耗费较大；list有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效，这在vector是不成立的

2、list的构造函数

list<T> lst;         //list采用采用模板类实现,对象的默认构造形式

list(beg,end);      //构造函数将[beg, end)区间中的元素拷贝给本身

list(n,elem);       //构造函数将n个elem拷贝给本身

list(const list &lst);  //拷贝构造函数

#include<iostream>
#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<int>L1;   //创建list容器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(L2);   //拷贝构造printList(L3);list<int>L4(4, 3000);   //n个elem方式构造printList(L4);
}int main() {test01();system("pause");return 0;
}

3、list的赋值和交换操作

assign(beg, end);             //将[beg, end)区间中的数据拷贝赋值给本身

assign(n, elem);              //将n个elem拷贝赋值给本身

list& operator=(const list &lst);  //重载等号操作符

swap(lst);                   //将lst与本身的元素互换

#include<iostream>
#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<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());   //assign赋值printList(L3);list<int>L4;L4.assign(10, 100);                //n个elem赋值printList(L4);
}
void test02()
{list<int>L1;L1.push_back(10);L1.push_back(20);L1.push_back(30);L1.push_back(40);cout << "交换前：" << endl;printList(L1);list<int>L2;L2.assign(10, 100);printList(L2);cout << "交换后：" << endl;L1.swap(L2);printList(L1);printList(L2);
}int main() {test01();test02();system("pause");return 0;
}

4、list的大小

size();       //返回容器中元素的个数

empty();     //判断容器是否为空

resize(num);  //重新指定容器的长度为num，若容器变长，则以默认值填充新位置

​   //如果容器变短，则末尾超出容器长度的元素被删除

resize(num, elem);  //重新指定容器的长度为num，若容器变长，则以elem值填充新位置

   //如果容器变短，则末尾超出容器长度的元素被删除

#include<iostream>
#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<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;}cout << "L1的元素个数（大小）为： " << L1.size() << endl;L1.resize(8);printList(L1);L1.resize(3);printList(L1);L1.resize(10, 80);printList(L1);
}int main() {test01();system("pause");return 0;
}

5、list的插入和删除

push_back(elem);    //在容器尾部加入一个元素

pop_back();         //删除容器中最后一个元素

push_front(elem);    //在容器开头插入一个元素

pop_front();         //从容器开头移除第一个元素

insert(pos,elem);     //在pos位置插elem元素的拷贝，返回新数据的位置

insert(pos,n,elem);   //在pos位置插入n个elem数据，无返回值

insert(pos,beg,end);  //在pos位置插入[beg,end)区间的数据，无返回值

clear();            //移除容器的所有数据

erase(beg,end);     //删除[beg,end)区间的数据，返回下一个数据的位置

erase(pos);         //删除pos位置的数据，返回下一个数据的位置

remove(elem);      //删除容器中所有与elem值匹配的元素

#include<iostream>
#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<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);//插入list<int>::iterator it = L.begin();L.insert(++it, 1000);printList(L);//删除it = L.begin();L.erase(++it);printList(L);//移除L.push_back(10000);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;
}

6、list的数据存取

front();   //返回第一个元素

back();   //返回最后一个元素

#include<iostream>
#include<list>
using namespace std;void test01()
{list<int> L;L.push_back(10);L.push_back(20);L.push_back(30);L.push_back(40);cout << "第一个元素为：" << L.front() << endl;cout << "最后一个元素为：" << L.back() << endl;//cout << "第一个元素为：" << L[0] << endl;       不可以用[]访问list中的元素//cout << "最后一个元素为：" << L.at(0) << endl;  不可以用at访问list中的元素list<int>::iterator it = L.begin();it++;  //支持递增和递减（双向）it--;//it = it + 1;   list本质是链表，不是用连续线性空间存储数据的，迭代器不支持随机访问
}int main() {test01();system("pause");return 0;
}

7、list的反转和排序算法

reverse();  //反转链表（元素逆序存储）

sort();     //链表排序（给链表的元素排序）

#include<iostream>
#include<list>
#include<algorithm>
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<int> L;L.push_back(10);L.push_back(50);L.push_back(40);L.push_back(30);L.push_back(20);printList(L);L.reverse();  //反转printList(L);
}
bool myCompare(int v1,int v2)
{//降序--第一个数＞第二个数return v1 > v2;//升序--第二个数＜第一个数
}void test02()
{list<int> L;L.push_back(10);L.push_back(50);L.push_back(40);L.push_back(30);L.push_back(20);printList(L);//sort(L.begin(), L.end())     所有不支持随机访问迭代器的容器，都不可以用标准算法，但它们内部会提供对应的一些算法L.sort();           //默认升序（从小到大）printList(L);L.sort(myCompare);  //降序printList(L);   
}int main() {test01();test02();system("pause");return 0;
}

8、案例

（1）案例描述：将Person自定义数据类型进行排序，Person中属性有姓名、年龄、身高，按照年龄进行升序排序，如果年龄相同，按照身高进行降序排序。

（2）代码：

#include<iostream>
#include<list>
#include<string>
using namespace std;class Person
{
public:string m_Name;int m_Age;int m_Height;Person(string name, int age, int height){this->m_Age = age;this->m_Height = height;this->m_Name = name;}
};void printList(const list<Person> &L)
{for (list<Person>::const_iterator it = L.begin(); it != L.end(); it++){cout << "姓名： " << (*it).m_Name << " 年龄： " << (*it).m_Age << " 身高： " << it->m_Height << endl;}cout << endl;
}
bool myCompare(Person &v1, Person &v2)
{if (v1.m_Age != v2.m_Age){return v1.m_Age < v2.m_Age;}else{return v1.m_Height > v2.m_Height;}
}void test01()
{list<Person>P;Person p1("张三", 19, 173);Person p2("李四", 34, 183);Person p3("王五", 26, 163);Person p4("刘六", 26, 170);P.push_back(p1);P.push_back(p2);P.push_back(p3);P.push_back(p4);P.sort(myCompare);printList(P);
}int main() {test01();system("pause");return 0;
}

八、set/multiset容器

1、set/multiset的基本概念

（1）所有元素都会在插入set/multiset容器时自动被排序。

（2）set/multiset属于关联式容器，底层结构是用二叉树实现。

（3）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(10);             //只有insert能插入数据s1.insert(20);s1.insert(40);s1.insert(30);s1.insert(10);printSet(s1);              //插进set容器的数据会自动排序，且不会存在重复值set<int>s2(s1);    //拷贝构造printSet(s2);set<int>s3;s3 = s2;           //赋值
}int main() {test01();system("pause");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(10);s1.insert(20);s1.insert(40);s1.insert(30);printSet(s1);if (s1.empty()){cout << "s1为空" << endl;}else{cout << "s1的大小为：" << s1.size() << endl;}
}
void test02()
{set<int>s1;s1.insert(10);s1.insert(20);s1.insert(40);s1.insert(30);printSet(s1);set<int>s2;s2.insert(11);s2.insert(21);s2.insert(41);s2.insert(31);printSet(s2);s1.swap(s2);printSet(s1);printSet(s2);
}int main() {test01();test02();system("pause");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(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;
}

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(10);s1.insert(30);s1.insert(20);s1.insert(40);printSet(s1);set<int>::iterator pos = s1.find(30);if (pos != s1.end()){cout << "找到元素" << *pos << endl;}else{cout << "未找到元素" << endl;}pos = s1.find(50);if (pos != s1.end()){cout << "找到元素" << *pos << endl;}else{cout << "未找到元素" << endl;}
}
void test02()
{set<int> s1;s1.insert(10);s1.insert(30);s1.insert(30);s1.insert(20);s1.insert(40);printSet(s1);int num = s1.count(30);cout << "“30”元素有" << num << "个" << endl;  //结果要么是0，要么是1num = s1.count(300);cout << "“300”元素有" << num << "个" << endl;
}int main() {test01();test02();system("pause");return 0;
}

6、set和multiset的区别

（1）set不可以插入重复数据，而multiset可以。

（2）set插入数据的同时会返回插入结果，表示插入是否成功。

（3）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 test01()
{set<int> s1;s1.insert(30);s1.insert(30);s1.insert(20);s1.insert(40);printSet(s1);pair<set<int>::iterator, bool>ret = s1.insert(10);if (ret.second){cout << "第一次插入成功" << endl;}else{cout << "第一次插入失败" << endl;}printSet(s1);ret = s1.insert(10);if (ret.second){cout << "第二次插入成功" << endl;}else{cout << "第二次插入失败" << endl;}printSet(s1);multiset<int> ss1;ss1.insert(30);ss1.insert(30);ss1.insert(20);ss1.insert(40);ss1.insert(30);ss1.insert(30);ss1.insert(20);ss1.insert(40);for (multiset<int>::iterator it = ss1.begin(); it != ss1.end(); it++){cout << *it << " ";}cout << endl;
}int main() {test01();system("pause");return 0;
}

7、set容器的排序规则

（1）set容器默认排序规则为从小到大，利用仿函数可以改变排序规则.

（2）举例：

①例1：

#include<iostream>
#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,MyCompare>::iterator it = s2.begin(); it != s2.end(); it++){cout << *it << " ";}cout << endl;
}int main() {test01();system("pause");return 0;
}

②例2：

#include<iostream>
#include<set>
#include<string>
using namespace std;class Person
{
public:int m_Age;string m_Name;Person(int age,string name){this->m_Age = age;this->m_Name = name;}
};class MyCompare
{
public:bool operator()(const Person &v1,const Person &v2){return v1.m_Age > v2.m_Age;}
};void test01()
{set<Person,MyCompare>p;Person p1( 19 ,"张三");Person p2( 34 ,"李四");Person p3( 26 ,"王五");Person p4( 28 ,"刘六");p.insert(p1);p.insert(p2);p.insert(p3);p.insert(p4);for (set<Person, MyCompare>::iterator it = p.begin(); it != p.end(); it++){cout << "姓名：" << it->m_Name << " 年龄：" << it->m_Age;cout << endl;}
}int main() {test01();system("pause");return 0;
}

③例3：

#include<iostream>
#include<set>
#include<string>
using namespace std;class Person
{
public:int m_Age;string m_Name;Person(int age,string name){this->m_Age = age;this->m_Name = name;}
};class MyCompare
{
public:bool operator()(const Person &v1,const Person &v2){return v1.m_Age > v2.m_Age;}
};void test01()
{multiset<Person,MyCompare>p;Person p1( 19 ,"张三");Person p2( 34 ,"李四");Person p3( 26 ,"王五");Person p4( 26 ,"刘六");p.insert(p1);p.insert(p2);p.insert(p3);p.insert(p4);for (multiset<Person, MyCompare>::iterator it = p.begin(); it != p.end(); it++){cout << "姓名：" << it->m_Name << " 年龄：" << it->m_Age;cout << endl;}
}int main() {test01();system("pause");return 0;
}

九、map/multimap容器

1、map的基本概念

（1）map中所有元素都是pair，pair中第一个元素为key（键值），起到索引作用，第二个元素为value（实值）。

（2）map中的所有元素都会根据元素的键值自动排序。

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

（4）map的特点是可以根据key值快速找到value值。

（5）map和multimap的区别：map不允许容器中有重复key值的元素，multimap允许容器中有重复key值的元素。

2、pair对组创建

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

（2）两个数据的数据类型可以不同。

//对组的定义

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

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

//访问对组的元素

p.first    //第一个元素

p.second  //第二个元素

#include<iostream>
#include<string>
using namespace std;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;
}

3、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<int, int> m;m.insert(pair<int, int>(1, 10));m.insert(pair<int, int>(3, 20));m.insert(pair<int, int>(2, 30));m.insert(pair<int, int>(2, 30));  //key值重复，无法插入m.insert(pair<int, int>(2, 20));  //key值重复，无法插入m.insert(pair<int, int>(4, 40));printMap(m);map<int, int> m2(m);printMap(m2);map<int, int> m3;m3 = m2;printMap(m3);
}int main() {test01();system("pause");return 0;
}

4、map的大小和交换操作

size();    //返回容器中元素的数目

empty();  //判断容器是否为空

swap(st);  //交换两个集合容器

#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> m;m.insert(pair<int, int>(1, 10));m.insert(pair<int, int>(3, 20));m.insert(pair<int, int>(2, 30));m.insert(pair<int, int>(4, 40));if (m.empty()){cout << "map容器为空" << endl;}else{cout << "map容器的元素个数为：" << m.size() << endl;}
}
void test02()
{map<int, int> m;m.insert(pair<int, int>(1, 10));m.insert(pair<int, int>(3, 20));m.insert(pair<int, int>(2, 30));m.insert(pair<int, int>(4, 40));printMap(m);map<int, int> m2;m2.insert(pair<int, int>(5, 100));m2.insert(pair<int, int>(6, 200));m2.insert(pair<int, int>(2, 300));m2.insert(pair<int, int>(8, 400));printMap(m2);m.swap(m2);printMap(m);printMap(m2);
}int main() {test01();test02();system("pause");return 0;
}

5、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<int, int> m;m.insert(pair<int, int>(1, 10));  //建议m.insert(make_pair(2, 30));       //建议m.insert(map<int, int>::value_type(3, 20));   //不建议m[4] = 40;                                    //不建议用于插入，不过[]可以用于访问valueprintMap(m);cout << m[5] << endl;   //不存在key=5，直接输出0，顺便插入了pair<int, int>(5, 0)cout << m[4] << endl;printMap(m);m.erase(--m.end());printMap(m);m.erase(2);    //删除 key = 2 一组的数据printMap(m);//清空//m.erase(m.begin(), m.end());m.clear();printMap(m);
}int main() {test01();system("pause");return 0;
}

6、map查找和统计操作

find(key);     //查找key是否存在，若存在则返回该键的元素的迭代器，若不存在则返回end()

count(key);  //统计key的元素个数

#include<iostream>
#include<map>
using namespace std;void test01()
{map<int, int> m;m.insert(pair<int, int>(1, 10));m.insert(pair<int, int>(3, 20));m.insert(pair<int, int>(3, 30));m.insert(pair<int, int>(2, 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;  //map不允许插入重复key元素，num要么为0，要么为1，不过multimap就不一定了
}int main() {test01();system("pause");return 0;
}

7、map容器排序规则

（1）map容器默认排序规则为按照key值进行从小到大排序，利用仿函数可以改变排序规则。

（2）举例：

①例1：

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

②例2：

#include<iostream>
#include<map>
#include<string>
using namespace std;class Person
{
public:int m_Age;string m_Name;Person(int age, string name){this->m_Age = age;this->m_Name = name;}
};
class MyCompare
{
public:bool operator()(const Person &p1, const Person &p2){return p1.m_Age > p2.m_Age;}
};void test01()
{map<Person, int, MyCompare>m;Person p1(19, "张三");Person p2(34, "李四");Person p3(26, "王五");Person p4(28, "刘六");m.insert(make_pair(p1, 10));m.insert(make_pair(p2, 20));m.insert(make_pair(p3, 40));m.insert(make_pair(p4, 30));for (map < Person, int, MyCompare>::iterator it = m.begin(); it != m.end(); it++){cout << "姓名： " << it->first.m_Name << " 年龄：" << it->first.m_Age << endl;}
}int main() {test01();system("pause");return 0;
}

十、终极案例

1、案例描述

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

（2）员工信息有姓名和工资，部门分为策划、美术、研发三个部门。

（3）随机给10名员工分配部门和工资。

（4）通过multimap进行信息的插入key（部门编号）——value（员工）。

（5）分部门显示员工信息。

2、实现步骤

（1）创建10名员工，放到vector中。

（2）遍历vector容器，取出每个员工，进行随机分组。

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

（4）分部门显示员工信息。

3、代码

#include<iostream>
#include<map>
#include<vector>
#include<string>
#include<time.h>
using namespace std;class Worker
{
public:string m_Name;int m_Salary;/*Worker(){m_Name = name;m_Salary = Salary;}*/
};
void createWorker(vector<Worker>&v)
{string str = "ABCDEFGHIJ";for (int i = 0; i < 10; i++){Worker worker;worker.m_Name = "员工";worker.m_Name += str[i];worker.m_Salary = rand() % 10000 + 10000;v.push_back(worker);}
}
void setGroup(multimap<string, Worker>&m , vector<Worker>&v)
{vector<Worker>::iterator it = v.begin();for (int i = 0; i < 10; i++){int key = rand() % 3 + 1;string bumen;switch (key){case 1:bumen = "策划";break;case 2:bumen = "美术";break;case 3:bumen = "研发";break;default:break;}m.insert(make_pair(bumen, *(it++)));}
}
void showWorkerByGourp(multimap<string, Worker>&m)
{multimap<string, Worker>::iterator it = m.begin();cout << "策划部门：" << endl;for (int i = 0 ; it != m.end() && i < m.count("策划"); it++ , i++){cout << "  姓名：" << it->second.m_Name << "  工资：" << it->second.m_Salary << endl;}cout << "---------------------------" << endl;cout << "美术部门：" << endl;for (int i = 0; it != m.end() && i < m.count("美术"); it++, i++){cout << "  姓名：" << it->second.m_Name << "  工资：" << it->second.m_Salary << endl;}cout << "---------------------------" << endl;cout << "研发部门：" << endl;for (int i = 0; it != m.end() && i < m.count("研发"); it++, i++){cout << "  姓名：" << it->second.m_Name << "  工资：" << it->second.m_Salary << endl;}
}void test01()
{vector<Worker>vWorker;createWorker(vWorker);/*for (vector<Worker>::iterator it = vWorker.begin(); it != vWorker.end(); it++){cout << it->m_Name << "  ";}cout << endl;*/multimap<string, Worker>mGroup;setGroup(mGroup, vWorker);showWorkerByGourp(mGroup);/*for (multimap<string, Worker>::iterator it = mGroup.begin(); it != mGroup.end(); it++){cout << "部门：" << it->first << "  姓名：" << it->second.m_Name << "  工资：" << it->second.m_Salary << endl;}*/
}int main() {srand((unsigned int)time(NULL));test01();system("pause");return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/694213.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

《VitePress 简易速速上手小册》第2章：Markdown 与页面创建（2024 最新版）

《VitePress 简易速速上手小册》第2章：Markdown 与页面创建（2024 最新版）

文章目录 2.1 Markdown 基础及扩展2.1.1 基础知识点解析2.1.2 重点案例&#xff1a;技术博客2.1.3 拓展案例 1&#xff1a;食谱分享2.1.4 拓展案例 2&#xff1a;个人旅行日记 2.2 页面结构与布局设计2.2.1 基础知识点解析2.2.2 重点案例&#xff1a;公司官网2.2.3 拓展案例 1&…
阅读更多...
jwt+redis实现登录认证

jwt+redis实现登录认证

项目环境&#xff1a;spring boot项目 pom.xml引入jwt和redis <!-- jwt --><dependency><groupId>com.auth0</groupId><artifactId>java-jwt</artifactId><version>4.3.0</version></dependency><!-- redis坐标-->…
阅读更多...
数据结构与算法：队列

数据结构与算法：队列

在上篇文章讲解了栈之后&#xff0c;本篇也对这一章进行收尾&#xff0c;来到队列&#xff01; 队列 队列的介绍队列的存储结构队列顺序存储的不足之处 循环队列的定义队列的链式存储结构链队列的构建链队列的初始化队尾入队队头出队获取队头队尾元素判断队列是否为空获取队列元…
阅读更多...
【Java前端技术栈】模块化编程

【Java前端技术栈】模块化编程

一、基本介绍 1.基本介绍 1 传统非模块化开发有如下的缺点&#xff1a;(1)命名冲突 (2)文件依赖 2 Javascript 代码越来越庞大&#xff0c;Javascript 引入模块化编程&#xff0c;开发者只需要实现核心的业务逻辑&#xff0c;其他都可以加载别人已经写好的模块 3 Javascrip…
阅读更多...
torch.utils.data

torch.utils.data

整体架构 平时使用 pytorch 加载数据时大概是这样的&#xff1a; import numpy as np from torch.utils.data import Dataset, DataLoaderclass ExampleDataset(Dataset):def __init__(self):self.data [1, 2, 3, 4, 5]def __getitem__(self, idx):return self.data[idx]def…
阅读更多...
网络入门基础

网络入门基础

本专栏内容为&#xff1a;Linux学习专栏&#xff0c;分为系统和网络两部分。 通过本专栏的深入学习&#xff0c;你可以了解并掌握Linux。 &#x1f493;博主csdn个人主页&#xff1a;小小unicorn ⏩专栏分类&#xff1a;网络 &#x1f69a;代码仓库&#xff1a;小小unicorn的代…
阅读更多...
32FLASH闪存

32FLASH闪存

目录 一&#xff0e;FLASH简介 二&#xff0e;代码实现 &#xff08;1&#xff09;读写内部FLASH &#xff08;2&#xff09;读取芯片ID 一&#xff0e;FLASH简介 存储器地址要记得累 系统存储器是原厂写入的Bootloader程序&#xff08;用于串口下载&#xff09;&#xff0…
阅读更多...
Python 写网络监控

Python 写网络监控

大家好&#xff01;我是爱摸鱼的小鸿&#xff0c;关注我&#xff0c;收看每期的编程干货。 网络监控是保障网络可靠性的一项重要任务。通过实时监控网络性能&#xff0c;我们可以及时发现异常&#xff0c;迅速采取措施&#xff0c;保障网络畅通无阻。本文将以 Python为工具&…
阅读更多...
Windows / Linux dir 命令

Windows / Linux dir 命令

Windows / Linux dir 命令 1. dir2. dir *.* > data.txt3. dir - list directory contentsReferences 1. dir 显示目录的文件和子目录的列表。 Microsoft Windows [版本 10.0.18363.900] (c) 2019 Microsoft Corporation。保留所有权利。C:\Users\cheng>dir驱动器 C 中…
阅读更多...
线性代数：向量组的秩

线性代数：向量组的秩

目录 回顾“秩” 及 向量组线性表示 相关特性 向量组的秩 例1 例2 矩阵的“秩” 及 向量组线性表示 相关特性 向量组的秩 例1 例2
阅读更多...
@Async引发的spring循环依赖的问题，

@Async引发的spring循环依赖的问题，

今天发现一个很有意思的问题&#xff0c;正常解决项目中产生的循环依赖&#xff0c;是找出今天添加的注入代码&#xff0c;然后一个个加lazy试过去&#xff0c;会涉及到类中新增的注入 但是今天修改了某个serviceimpl的方法&#xff0c;加入了Async方法后 就发生循环依赖了 ai…
阅读更多...
如何实现一个K8S DevicePlugin?

如何实现一个K8S DevicePlugin?

什么是device plugin k8s允许限制容器对资源的使用&#xff0c;比如CPU和内存&#xff0c;并以此作为调度的依据。 当其他非官方支持的设备类型需要参与到k8s的工作流程中时&#xff0c;就需要实现一个device plugin。 Kubernetes提供了一个设备插件框架&#xff0c;你可以用…
阅读更多...
机器视觉系统选型-为什么还要选用工业光源控制器

机器视觉系统选型-为什么还要选用工业光源控制器

工业光源控制器最主要的用途是给光源供电&#xff0c;实现光源的正常工作。 1.开关电源启动时&#xff0c;电压是具有波浪的不稳定电压&#xff0c;其瞬间峰值电压超过了LED灯的耐压值&#xff0c;灯珠在多次高压冲击下严重降低了使用寿命&#xff1b; 2.使用专用的光源控制器&…
阅读更多...
inBuilder低代码平台新特性推荐-第十六期

inBuilder低代码平台新特性推荐-第十六期

各位友友们&#xff0c;大家好~今天来给大家介绍一下inBuilder低代码平台社区版中的系列特性之一 —— 构件热加载&#xff01; 01 概述 构件热加载指的是&#xff1a;构件代码修改后&#xff0c;无需重启应用&#xff0c;通过WebIDE的部署或发布工程后&#xff0c;即可正常调…
阅读更多...
08-静态pod（了解即可，不重要）

08-静态pod（了解即可，不重要）

我们都知道&#xff0c;pod是kubelet创建的&#xff0c;那么创建的流程是什么呐&#xff1f; 此时我们需要了解我们k8s中config.yaml配置文件了&#xff1b; 他的存放路径&#xff1a;【/var/lib/kubelet/config.yaml】 一、查看静态pod的路径 [rootk8s231 ~]# vim /var/lib…
阅读更多...
华为配置直连三层组网直接转发示例

华为配置直连三层组网直接转发示例

华为配置直连三层组网直接转发示例 组网图形 图1 配置直连三层组网直接转发示例组网图 业务需求组网需求数据规划配置思路配置注意事项操作步骤配置文件扩展阅读 业务需求 企业用户接入WLAN网络&#xff0c;以满足移动办公的最基本需求。且在覆盖区域内移动发生漫游时&#xff…
阅读更多...
LeetCode 算法题 （数组）存在连续3个奇数的数组

LeetCode 算法题 （数组）存在连续3个奇数的数组

问题&#xff1a; 输入一个数组&#xff0c;并输入长度&#xff0c;判断数组中是否存在连续3个元素都是奇数的情况&#xff0c;如果存在返回存在连续3个元素都是奇数的情况&#xff0c;不存在返回不存在连续3个元素都是奇数的情况 例一&#xff1a; 输入&#xff1a;a[1,2,3…
阅读更多...
数论 - 博弈论（Nim游戏）

数论 - 博弈论（Nim游戏）

文章目录 前言一、Nim游戏1.题目描述输入格式输出格式数据范围输入样例&#xff1a;输出样例&#xff1a; 2.算法 二、台阶-Nim游戏1.题目描述输入格式输出格式数据范围输入样例&#xff1a;输出样例&#xff1a; 2.算法 三、集合-Nim游戏1.题目描述输入格式输出格式数据范围输…
阅读更多...
React18原理: React核心对象之ReactElement对象和Fiber对象

React18原理: React核心对象之ReactElement对象和Fiber对象

React中的核心对象 在React应用中&#xff0c;有很多特定的对象或数据结构.了解这些内部的设计&#xff0c;可以更容易理解react运行原理列举从react启动到渲染过程出现频率较高&#xff0c;影响范围较大的对象&#xff0c;它们贯穿整个react运行时 如 ReactElement 对象如 Fi…
阅读更多...
IO 作业 24/2/21

IO 作业 24/2/21

1、使用多线程完成两个文件的拷贝&#xff0c;第一个线程拷贝前一半&#xff0c;第二个线程拷贝后一半&#xff0c;主线程回收两个线程的资源 #include <myhead.h> //定义分支线程1 void *task1(void *arg) {int fdr-1;//只读打开被复制文件if((fdropen("./111.txt…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023