本文详细介绍了STL中的几种主要容器：vector、list、set和map的基本操作，包括构造、赋值、容量调整、插入删除、遍历、查找、排序等。此外，还探讨了自定义数据类型在容器中的应用，并提供了多个示例代码，帮助读者深入理解STL容器的使用方法。
STL容器
仅用于自学复习
#include<iostream>
#include<vector>
#include<string>
#include<list>
#include<set>
#include<map>
using namespace std;
//vector自定义数据类型
class Person {
public:
Person(string name, int age) {
this->m_Name = name;
this->m_Age = age;
}
string m_Name;
int m_Age;
};
void test() {
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);
//遍历容器中的数据
//it 相当于指针 为Person类型
for (vector<Person>::iterator it = v.begin(); it != v.end(); it++) {
cout << "姓名：" << (*it).m_Name << "年龄：" << it->m_Age << endl;
}
}
void test1() {
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);
//遍历容器中的数据
//it 相当于指针 为Person类型
for (vector<Person*>::iterator it = v.begin(); it != v.end(); it++) {
cout << "姓名：" << (*it)->m_Name << "年龄：" << (*it)->m_Age << endl;
}
}
//容器嵌套容器
void test2() {
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;
}
}
/*
String 容器
*/
//string 构造函数
/*
string(); //创建空字符串
string(const char* s); //使用字符串s初始化
string(const string& str); //使用string对象初始化另一个string对象
string(int n,char c); //使用n个字符c初始化
*/
void test3() {
string s1; //默认构造
const char * str = "hello ";
string s2(str);
cout << "s2= " << s2 << endl;
string s3(s2);
cout << "s3= " << s3 << endl;
string s4(10, 'a');
cout << "s4= " << s4 << endl;
}
//string 赋值
/*
string& operator = (const char* s);//char*类型字符串， 赋值给当前的字符串
string& operator = (const string &s);//把字符串s 赋值给当前的字符串
string& operator = (char c);//字符赋值给当前的字符串
string& assing(cosnt char *s) //把字符串s赋值给当前字符串
string& assing(cosnt char *s,int n) //把字符串s的前n个字符赋给当前字符串
string& assing(cosnt string &s) //把字符串s赋值给当前字符串
string& assing(int n,char c) //用n个字符c赋给当前字符串
*/
void test4() {
string str1;
str1 = "hello";
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 aasd");
cout << "str4 =" << str4 << endl;
string str5;
str5.assign("as", 5);
cout << "str5 =" << str5 << endl;
string str6;
str6.assign(str5);
cout << "str6 =" << str6 << endl;
string str7;
str7.assign(5, 'C');
cout << "str7 =" << str7 << endl;
}
//字符串的拼接
/*
string& operator+=(const char* str); //重载+=
string& operator+=(const cahr c);
string& operator+=(const string& str);
string& append(const char *s); //吧字符串s连接到当前字符串后
string& append(const char *s,int n);//把字符串前n个字符连接到当前字符串后
string& append(const string &s);//
string& append(const string &s,int pos,int n);//字符串s中从pos开始的n个字符连接到字符串结尾
*/
void test5() {
string str1 = "hahaha";
str1 += "你好？";
cout << "str1 =" << str1 << endl;
string str2 = "hello?";
str2 += str1;
cout << "str2 =" << str2 << endl;
string str3 = "111";
str3.append("lalalalala");
cout << "str3 =" << str3 << endl;
string str4 = "E:";
str4.append("ABCDEFG",3);
cout << "str4 =" << str4 << endl;
string str5 = "F:";
str5.append(str3);
cout << "str5 =" << str5 << endl;
string str6 = "G:";
string str7 = "MMMMMMMMMMMMMMM";
str6.append(str7,3,8);
cout << "str6 =" << str6 << endl;
}
//字符串查找和替换
/*
int find(const string& str,int pos=0) cosnt; //查找str第一次出现位置，从pos开始查找
int find(const char* s,int pos=0) cosnt; //查找s第一次出现位置，从pos开始查找
int find(const char* s,int pos,int n) cosnt; //从pos位置查找s的前n个字符的第一次位置
int find(const char c,int pos=0) cosnt; //查找c第一次出现位置
int rfind(const string& str,int pos=npos) cosnt; //查找str最后一次出现位置，从pos开始查找
int rfind(const char* s,int pos=0) cosnt; //查找s最后一次出现位置，从pos开始查找
int rfind(const string& str,int pos,int n) cosnt; //从pos位置查找s的前n个字符的最后一次位置
int rfind(const char c,int pos=0) cosnt; //查找c最后一次出现位置，从pos开始查找
string& replace(int pos,int n,const string& str); //替换从pos开始n个字符为字符串stc
string& replace(int pos,int n,const char* s);//替换从pos开始的n个字符为字符串 s
*/
//字符串比较 ascii码比较
/*
int compare(const string &s)const; //与字符串s比较
int compare(const char *s)const; //与字符串s比较
*/
void test7() {
string s1 = "hello";
string s2 = "Hello";
if (s1.compare(s2) == 0) {
cout << "s1 = s2" << endl;
}
if (s1.compare(s2) > 0) {
cout << "s1 > s2" << endl;
}
if (s1.compare(s2) < 0) {
cout << "s1 < s2" << endl;
}
}
//字符串存取
/*
char& operator[](int n) //通过[]方式取字符
char& at(int n) //通过at方法取
*/
void test8() {
string s1 = "ABCDEFGH";
/*for (int i = 0; i < s1.size(); i++) {
cout << s1[i] << endl;
}
for (int i = 0; i < s1.size(); i++) {
cout << s1.at(i) << endl;
}*/
//修改单个字符
s1[0] = 'W';
s1.at(1) = 'W';
cout << s1 << endl;
}
//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个字符
*/
void test9() {
string s1 = "ABCDE";
string s2 = "DDDD";
s1.insert(2, "CCCC");
s1.insert(3, s2);
s1.insert(4, 4, 'G');
s1.erase(3, 5);
cout << s1 << endl;
}
//子串获取
/*
striing substr(int pos = 0,int n = npos) const; //返回由pos开始的n个字符组成的字符串
*/
void test10() {
string s1 = "abcdefg";
string subStr = s1.substr(1, 3);
cout << " subStr = " << subStr << endl;
string email = "zhangaguo@qq.com";
int pos = email.find('@');
string strName = email.substr(0, pos);
cout << "strName = " << strName << endl;
}
/*
Vector容器
*/
//构造函数
/*
vector<T>v; //采用模板实现类实现，默认构造函数
vector(v.begin(),v.end()); //将v[begin(),end()]区间中的元素拷贝给本身
vector(n,elem); //构造函数将n个elem拷贝给本身
vector(const vector &vec) //拷贝构造函数
*/
void printVector(vector<int> &v) {
for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
cout<<*it << " ";
}
cout << endl;
}
void test11() {
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, 1);
printVector(v3);
//拷贝构造
vector<int> v4(v3);
printVector(v4);
}
//赋值
/*
vector& operator=(const)
*/
//vector 容量和大小
/*
empty() //判断是否为空
capacity() //容器的容量
size() //返回容器中元素个数
resize(int num) //重新指定容器的长度为num 若容器变长 则以默认值(0)填充新位置 若容器变短 则末尾超出容器长度的元素被删除
resize(int num,内容) //重新指定容器的长度为num 若容器变长 内容可以自定
*/
void test12() {
vector<int>v1;
for (int i = 0; i < 10; i++) {
v1.push_back(i);
}
printVector(v1);
cout << "容量： " << v1.capacity() << endl;
cout << "元素个数：" << v1.size() << endl;
v1.resize(13,9);
printVector(v1);
}
//vector插入 删除
/*
push_back() //尾部插入
pop_back() //删除最后一个元素
insert(conts_iterator pos,ele); //迭代器指向位置pos插入元素ele
insert(const_iterator pos,int count,ele); //迭代器指向位置pos插入count个元素ele
erase(const_iterator pos); //删除迭代器指向元素
erase(const_iterator start,const_itreator end); //删除迭代器从start到end之间的元素
clear() //清除所有元素
*/
void test13() {
vector<int>v1;
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v1.push_back(4);
v1.push_back(5);
printVector(v1);
//尾删
v1.pop_back();
printVector(v1);
//插入
v1.insert(v1.begin(), 20);
printVector(v1);
//删除
v1.erase(v1.begin());
printVector(v1);
v1.clear();
printVector(v1);
}
//vector 数据存取
/*
at()
operatro[]; //返回索引所指的元素
front(); //返回第一个元素
back(); //返回最后一个元素
*/
void test14() {
vector<int>v1;
for (int i = 0; i < 5; i++) {
v1.push_back(i);
}
cout << v1.at(2) << endl;
cout << v1[2] << endl;
cout << v1.front() << endl;
cout << v1.back() << endl;
}
//vecto 互换容器 将两个容器互换
/*
swap(vec); //将vec与本身的元素互换
*/
void test15() {
//基本使用
/* vector<int> v1;
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
}
cout << "互换前v1：" << endl;
printVector(v1);
vector<int>v2;
for (int i = 10; i >0; i--)
{
v2.push_back(i);
}
cout << "V2: " << endl;
printVector(v2);
cout << "v1,v2互换后：" << endl;
v1.swap(v2);
printVector(v1)*/;
//实际用途:收缩内存空间
vector<int>v;
for (int i = 0; i < 100000; i++)
{
v.push_back(i);
}
cout << "v的容量：" << v.capacity() << endl;
cout <<"v的大小为：" <<v.size()<< endl;
//重新指定大小
v.resize(4);
cout << "v重新指定后的情况" << endl;
cout << "v的容量：" << v.capacity() << endl;//容量为 138255 只用了4个其他浪费
cout << "v的大小为：" << v.size() << endl; //大小为4
//利用swap收缩内存
vector<int>(v).swap(v); // vector<int>(v):匿名对象 可以认为容器x .swap(v)：容器交换（指针交换） x与实际的v 即x指向 匿名定义后的地址 v指向实际的地址 例：x->大小为100000的容器 v->大小为4的容器
cout << "v利用swap收缩后的情况" << endl;
cout << "v的容量：" << v.capacity() << endl;//容量为 138255 只用了4个其他浪费
cout << "v的大小为：" << v.size() << endl; //大小为4
}
//vector 预留空间 减少vector动态扩展容量时的扩展次数
/*
reserve(int len); //容器预留len个元素长度，预留位置不初始化，元素不可访问
*/
void test16() {
vector<int>v;
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 << endl;*/
//预留空间
v.reserve(100000);
for (int i = 0; i < 100000; i++)
{
v.push_back(i);
if (p != &v[0]) {
p = &v[0];
num++;
}
}
cout << "预留空间后扩展内存次数:" << num << endl;
}
/*
list容器 迭代器只能进行前移和后移 不可以通过下标跳跃性访问某个元素;也不可以通过at进行访问 list本质是链表 数据不是用连续的线性空间存取数据
迭代器只能++ 不能+1
*/
void printList(const list<int>&L) {
for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
void test17() {
list<int>L1;
L1.push_back(1);
L1.push_back(2);
L1.push_back(3);
L1.push_back(4);
L1.push_back(5);
//同vector容器构造相同
printList(L1);
}
//list的赋值和交换 同stl其他容器相同
//list的插入和删除 与STL其他容器相同，多了一个remove
void test18() {
list<int>L;
for (int i = 0; i < 5; i++) {
L.push_back(i); //尾插
L.push_front(i - 5); //头插
}
cout << "L:";
printList(L);
//尾删
L.pop_back();
cout << "尾删：";
printList(L);
//头删
L.pop_front();
cout << "头删：";
printList(L);
//插入
L.insert(L.begin(), 50);
cout << "插入：";
printList(L);
list<int>::iterator it = L.begin();
L.insert(++it, 100);
L.insert(++it, 200);
L.insert(++it, 300);
cout << "迭代器插入：";
printList(L);
//删除
it = L.begin();
L.erase(it);
cout << "迭代器删除：";
printList(L);
//移除所有与某个元素匹配的元素
L.push_back(1000);
L.push_back(1000);
L.push_back(1000);
cout << "移除前：";
printList(L);
L.remove(1000);
cout << "移除后：";
printList(L);
}
//list 数据存取 反转和排序
/*
front() //返回第一个元素
back() //返回最后一个元素
reverse() //反转
sort() //排序
*/
//降序
bool myCompare(int v1, int v2) {
return v1 > v2;
}
void test19() {
list<int>L1;
//for (int i = 0; i < 10; i++)
//{
// L1.push_back(i);
//}
L1.push_back(213);
L1.push_back(21);
L1.push_back(13);
L1.push_back(23);
L1.push_back(43);
L1.push_back(1124);
L1.push_back(33);
L1.push_back(11);
cout << "原始：" << endl;
printList(L1);
L1.reverse();
cout << "反转：" << endl;
printList(L1);
//所以不支持随机访问迭代器的容器，不可以使用标准算法
//不支持随机访问迭代器的容器，内部会提供一些算法
L1.sort();
cout << "升序排序 ：" << endl;
printList(L1);
//sort(函数名) 自定义升降序
L1.sort(myCompare);
cout << "降序排序 ：" << endl;
printList(L1);
}
/*
排序案例
*/
class Person_l {
public:
string Name; //姓名
int Age, Height; //年龄、升高
//初始化属性
Person_l(string name, int age, int height) {
Name = name;
Age = age;
Height = height;
}
};
//指定排序规则
bool comparePerson_l(Person_l &p1, Person_l &p2) {
//return p1.Age > p2.Age; //按年龄降序
if (p1.Age == p2.Age) {
//年龄相同按照身高降序排序
if (p1.Height == p2.Height) {
//升高相同按姓氏排序
p1.Name > p2.Name;
}
return p1.Height > p2.Height;
}
return p1.Age < p2.Age; //按年龄升序
}
void test20() {
list<Person_l>L; //创建容器
//准备数据
Person_l p1("张珊",23,176);
Person_l p2("李四",15,186);
Person_l p3("王五",22,166);
Person_l p4("哈哈",15,186);
Person_l p5("哇喔",88,170);
L.push_back(p1);
L.push_back(p2);
L.push_back(p3);
L.push_back(p4);
L.push_back(p5);
//遍历
for (list<Person_l>::iterator it = L.begin(); it != L.end(); it++)
{
cout << "姓名：" << (*it).Name << " 年龄：" << it->Age << " 身高：" << it->Height << endl;
}
cout << "-------------------------------------------" << endl;
cout << "排序后：" << endl;
//自定义排序规则
L.sort(comparePerson_l);
for (list<Person_l>::iterator it = L.begin(); it != L.end(); it++)
{
cout << "姓名：" << (*it).Name << " 年龄：" << it->Age << " 身高：" << it->Height << endl;
}
}
/*
set/multiset 容器
set容器： 所有元素都会在插入是自动排序
set不允许容器中有重复的元素
multiset允许容器中有重复额元素
Set构造：
set<>st; //默认
set(cosnt set &st) //拷贝
*/
//遍历
void printSet(set<int>&s) {
for (set<int>::iterator it = s.begin(); it != s.end(); it++) {
cout << (*it) << " ";
}
cout << endl;
}
void set1() {
set<int>s1;
//插入元素只有 insert方式
s1.insert(1);
s1.insert(5);
s1.insert(4);
s1.insert(2);
s1.insert(23);
//遍历容器
printSet(s1);
}
//set大小和交换
/*
size()
empty()
swap()
*/
void set2() {
set<int>s1;
s1.insert(23);
s1.insert(222);
s1.insert(11);
s1.insert(21);
s1.insert(22);
cout << "原始cout:" << endl;
printSet(s1);
if (s1.empty()) {
cout << "s1为空" << endl;
}
else {
cout << "s1不为空" << endl;
}
cout << "s1大小：" << s1.size() << endl;
set<int>s2;
s2.insert(88);
s2.insert(8);
s2.insert(1288);
s2.insert(883);
cout << "交换前：" << endl;
printSet(s1);
printSet(s2);
cout << "交换后：" << endl;
s1.swap(s2);
printSet(s1);
printSet(s2);
}
//set 插入和删除
/*
insert()
clear()
erase()
*/
void set3() {
set<int>s1;
s1.insert(2);
s1.insert(12);
s1.insert(23);
s1.insert(5);
cout << "原始s1：" << endl;
printSet(s1);
//删除
s1.erase(s1.begin());
cout << "删除后：" << endl;
printSet(s1);
//删除重载（删除指定值
s1.erase(12);
cout << "删除12后：" << endl;
printSet(s1);
}
//set查找和统计
/*
find(key); //查找key是否存在，若存在，返回该键的元素的迭代器；弱不存在，返回set.end()
count(key); //统计key的个数
*/
void set4() {
set<int>s1;
s1.insert(4);
s1.insert(2);
s1.insert(6);
s1.insert(1);
s1.insert(7);
set<int>::iterator pos = s1.find(42);
if (pos != s1.end()) {
cout << "找到元素:" << *pos << endl;
}
else {
cout << "未找到元素" << endl;
}
//统计对于set而言 统计结果 为 1或0
}
//set、 multiset 区别
void set5() {
set<int>s;
//pair型
pair<set<int>::iterator, bool> ret = s.insert(10);
ret = s.insert(10);
if (ret.second) {
cout << "插入成功" << endl;
}
else {
cout << "插入失败" << endl;
}
multiset<int>ms;
ms.insert(1);
ms.insert(1);
ms.insert(1);
for (multiset<int>::iterator it = ms.begin(); it != ms.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
//set排序
class MyCompare { //仿函数 bool类型
public:
bool operator()(int v1, int v2) {
return v1 > v2;
}
};
void set6() {
set<int>s1;
s1.insert(4);
s1.insert(2);
s1.insert(6);
s1.insert(1);
s1.insert(7);
printSet(s1);
//指定排序规则 修改规则 在数据插入之前修改
set<int,MyCompare>s2;
s2.insert(4);
s2.insert(2);
s2.insert(6);
s2.insert(1);
s2.insert(7);
for (set<int, MyCompare>::iterator it = s2.begin(); it != s2.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
class MyCompare_P {
public:
bool operator()(const Person_l &p1, const Person_l &p2) {
if (p1.Age == p2.Age) {
if (p1.Height == p2.Height) {
return p1.Name > p2.Name;
}
return p1.Height > p2.Height;
}
return p1.Age > p2.Age;
}
};
//set 自定义数据类型排序
void set7() {
//自定义数据类型 必须要指定排序规则
set<Person_l, MyCompare_P>s1;
Person_l p1("张珊", 23, 176);
Person_l p2("李四", 15, 186);
Person_l p3("王五", 22, 166);
Person_l p4("哈哈", 15, 186);
Person_l p5("哇喔", 88, 170);
s1.insert(p1);
s1.insert(p2);
s1.insert(p3);
s1.insert(p4);
s1.insert(p5);
for (set<Person_l, MyCompare_P>::iterator it = s1.begin(); it != s1.end(); it++) {
cout <<"姓名：" << (*it).Name<<" 年龄："<<it->Age<<" 身高："<<it->Height<<endl;
}
}
/*
map : map中所有元素都是pair 成对出现 第一个元素为key 起索引作用 第二个为value
所有元素按键值自动排序
map/multimap 属于关联式容器 底层结构是二叉树
优点：可以根据key值快速找到value值
map与multimap区别：
map不允许容器中有重复key值
multimap运行有重复key值
*/
//map的构造和赋值
/*
map<T1,T2>mp;
map(const map &mp)
map& operator=(const map &mp);
*/
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 map1() {
//创建map容器
map<int, int>m;
m.insert(pair<int, int>(1, 10));
m.insert(pair<int, int>(2, 12));
m.insert(pair<int, int>(3, 14));
m.insert(pair<int, int>(4, 12));
printMap(m);
map<int, int>m2(m);
printMap(m2);
//赋值
map<int, int>m3;
m3 = m2;
printMap(m3);
}
//map大小交换
/*
size empty swap 同set
*/
//map 插入
void map2() {
map<int, int>m;
//第一种
m.insert(pair<int, int>(1, 2));
//第二种
m.insert(make_pair(12, 22));
//第三种
m.insert(map<int, int>::value_type(3, 32));
//第四种 若插入错误会根据key创建一个对应的value 不建议插入但可以查询
m[4] = 40;
cout << m[5] << endl;
printMap(m);
//删除第一个
m.erase(m.begin());
printMap(m);
//按照key删除
m.erase(5);
printMap(m);
//清空
m.clear();
printMap(m);
m.erase(m.begin(), m.end());
printMap(m);
}
//map查找和统计
/*
find(key); //查找key是否存在，若存在返回该键的元素的迭代器，不存在返回end()
coutn(key; //统计key的元素个数
*/
void map3() {
map<int, int> m;
m.insert(make_pair(1, 22));
m.insert(make_pair(2, 202));
m.insert(make_pair(3, 612));
m.insert(make_pair(4, 52));
m.insert(make_pair(5, 32));
map<int, int>::iterator pos = m.find(2);
if (pos != m.end()) {
cout << "找到了该key" << pos->first << " value=" << (*pos).second << endl;
}
else {
cout << " 为找到该key" << endl;
}
//统计
//map不允许插入重复key元素 count的值为1 或 0
//multimap 允许插入重复的key 所以count的值可以大于1
int num = m.count(3);
cout << "num="<<num << endl;
}
//map排序
class MyCompare_m {
public:
bool operator()(int v1,int v2){
return v1 > v2;
}
};
void map4() {
//map<int, int>m;
//m.insert(make_pair(1, 22));
//m.insert(make_pair(2, 202));
//m.insert(make_pair(3, 612));
//m.insert(make_pair(4, 52));
//m.insert(make_pair(5, 32));
//cout << "默认排序：" << endl;
//printMap(m);
////自定义排序
//map<int, int, MyCompare_m>m1;
//m1.insert(make_pair(1, 22));
//m1.insert(make_pair(2, 202));
//m1.insert(make_pair(3, 612));
//m1.insert(make_pair(4, 52));
//m1.insert(make_pair(5, 32));
//cout << "自定义排序:" << endl;
//for (map<int, int, MyCompare_m>::iterator it = m1.begin(); it != m1.end(); it++) {
// cout << "key = " << it->first << " value= " << (*it).second << endl;
//}
//自定义类型数据排序 map必须要指定排序规则 同set
map<Person_l,int, MyCompare_P>m2;
Person_l p1("张珊", 23, 176);
Person_l p2("李四", 15, 186);
Person_l p3("王五", 22, 166);
Person_l p4("哈哈", 15, 186);
Person_l p5("哇喔", 88, 170);
m2.insert(make_pair( p1,1));
m2.insert(make_pair( p2,2));
m2.insert(make_pair( p3,4));
m2.insert(make_pair( p4,4));
m2.insert(make_pair( p5,5));
for (map<Person_l, int, MyCompare_P>::iterator it = m2.begin(); it != m2.end(); it++) {
cout << "key：" << it->second << " 姓名：" << (*it).first.Name << " 年龄：" << it->first.Age << " 身高：" << it->first.Height<< endl;
}
cout << endl;
}
int main()
{
//test();
//test1();
//test2();
//test3();
//test4();
//test5();
//test7();
//test8();
//test9();
//test10();
//test11();
//test12();
//test13();
//test14();
//test15();
//test16();
//test17();
//test18();
//test19();
//test20();
//set1();
//set2();
//set3();
//set4();
//set5();
//set6();
//set7();
//map1();
//map2();
//map3();
map4();
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
