学校网站建设内容设计,网站建设需要考哪些证,申请做网站、论坛版主,网页出现网站维护文章目录#xff1a;1.vector1.1 遍历方式1.2 构造函数1.3 容量大小问题1.4 插入和删除1.5 存取值1.6 交换两个vectot的元素1.7 预定义存储空间2.string3. deque4. stack4.1 常用函数5. queue5.1 特点5.2 方法6. list6.1 优点6.2 缺点6.3 构造函数6.4 交换6.5 大小6.6 插入和删…
文章目录1.vector1.1 遍历方式1.2 构造函数1.3 容量大小问题1.4 插入和删除1.5 存取值1.6 交换两个vectot的元素1.7 预定义存储空间2.string3. deque4. stack4.1 常用函数5. queue5.1 特点5.2 方法6. list6.1 优点6.2 缺点6.3 构造函数6.4 交换6.5 大小6.6 插入和删除6.7 排序和反转7. set7.1 方法7.2 pair 对数创建7.3 排序8. map8.1 插入元素大小与交换8.2 查找与统计8.3 排序1.vector
1.1 遍历方式
for_each(v.begin(),v.end(),myPrint)// myPrint为自定义vector输出函数
1.2 构造函数
vector v2(v1.begin(),v1.end()); vector v2(10,1000);// 存储10个1000 vector v2(v1);// 将v1赋给v1 vector v2; v2.assign(10,1000);// 存储10个1000
1.3 容量大小问题
capacity和size的区别 capacity是系统开辟的空间这个空间可能大于定义的大小作为备用存储空间 size是开辟的空间大小 一般capacitysize没有备用空间。 在尾部添加push_back时系统会找一个足够大的空间并将原来的数组复制过去 但一般会额外多开辟新备用空间防止反复移动整个数组而导致运行效率降低的问题
1.4 插入和删除
pop_back()删除最后一个元素 insert(v.begin(),100)在开始位置插入100 insert(v.begin(),2,1000)在开始位置插入2个1000 erase(v1.begin())移除第一元素值 erase(v1.begin(),v1.end())// 删除所有元素不会清除开辟的空间size clear()会清空vetor中的所有元素包括开辟的空间size但是capacity会保留这时不可以用下标的形式赋值只能通过push_back函数。
1.5 存取值
可通过[]下标的形式和at()函数 front()返回第一个元素值 back()返回最后一个元素值
1.6 交换两个vectot的元素
v1.swap(v2)交换v1和v2的元素值
1.7 预定义存储空间
reserve(10000) 开辟预留空间防止vector多次赋值导致的效率降低
#includeiostream
#includealgorithm
#includevectorusing namespace std;class Person {public:
string myname;
int myage;
Person(string name, int age) {
myname name;
myage age;
}
};
void myPrint(int val) {
cout val endl;
}void test() {
vectorint v;// 定义存储int整形的向量
v.push_back(10);// 向向量中传值
v.push_back(20);
v.push_back(30);
v.push_back(40);vectorint::iterator pBegin v.begin();// 定义迭代器迭代器指向第一个元素
vectorint::iterator pEnd v.end();// 定义迭代器迭代器指向最后一个元素// 遍历vector
while (pBegin ! pEnd) {
cout *pBegin endl;
pBegin;
}
// 遍历vector
for (vectorint::iterator it v.begin(); it ! v.end(); it) {
cout *it endl;
}
// 遍历vector加强型循环
for_each(v.begin(), v.end(), myPrint);}
// 存放自定义数据类型
void test01() {
vectorPerson v;
Person p1(aaa, 10);// 实例化对象
Person p2(bbb, 20);
Person p3(ccc, 30);
Person p4(ddd, 40);v.push_back(p1);
v.push_back(p2);
v.push_back(p3);
v.push_back(p4);for (vectorPerson::iterator it v.begin(); it ! v.end(); it) {
cout name: (*it).myname age: (*it).myage endl;
}
}
// 定义存储自定义对象地址
void test02() {
vectorPerson* v;
Person p1(aaa, 10);
Person p2(aaa, 20);
Person p3(aaa, 30);
Person p4(aaa, 40);v.push_back(p1);
v.push_back(p2);
v.push_back(p3);
v.push_back(p4);for (vectorPerson*::iterator it v.begin(); it ! v.end(); it) {
Person *p (*it);
cout name: p-myname age: p-myage endl;
}}
// 嵌套存储vector的vector
void test03() {
vectorvectorint v;
vectorint a1;
vectorint a2;
vectorint a3;
vectorint a4;a1.push_back(10);
a1.push_back(20);
a1.push_back(30);
a1.push_back(40);v.push_back(a1);
v.push_back(a2);
v.push_back(a3);
v.push_back(a4);// 需要用到两个for循环第一个返回的是vector第二个是遍历返回的vector
for (vectorvectorint::iterator it v.begin(); it ! v.end(); it) {
for (vectorint::iterator vit (*it).begin(); vit ! (*it).end(); vit) {
cout *vit endl;
}
}
}// vector赋值
void printVector(vectorint v) {
for (vectorint::iterator it v.begin(); it ! v.end(); it) {
cout *it ;}
cout endl;
}
// vectot构造函数
void test04() {
vectorint v1;
for (int i 0; i 4; i) {
v1.push_back(i);
}
printVector(v1);vectorint v2(v1.begin(), v1.end());
printVector(v2);vectorint v3(10, 100);
printVector(v3);vectorint v4(v3);
printVector(v4);}
// vecotr赋值
void test05() {
vectorint v1;
for (int i 0; i 4; i) {
v1.push_back(i);
}
printVector(v1);vectorint v2 v1;
printVector(v2);vectorint v3;
v3.assign(v1.begin(), v1.end());
printVector(v3);vectorint v4;
v4.assign(10, 100);// 10个100进行赋值
printVector(v4);
}//vector大小操作
/* TODO capacity和size的区别capacity是系统开辟的空间这个空间可能大于定义的大小作为备用存储空间
size是开辟的空间大小
一般capacitysize没有备用空间。
在尾部添加push_back时系统会找一个足够大的空间并将原来的数组复制过去
但一般会额外多开辟新备用空间防止反复移动整个数组而导致运行效率降低的问题
*/void test06() {
vectorint v1;
for (int i 0; i 4; 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, 10);// 指定大默认用0填充这里用用10填充
printVector(v1);v1.resize(5);// 指定小超过部分将被删除
printVector(v1);
}// 插入和删除
void test07() {
vectorint v1;
for (int i 0; i 4; i) {
v1.push_back(i);
}
printVector(v1);v1.pop_back();// 删除最后一个元素
printVector(v1);v1.insert(v1.begin(), 100);// 在开始位置插入100
printVector(v1);v1.insert(v1.begin(), 2, 1000);// 在开始位置插入两个1000
printVector(v1);v1.erase(v1.begin());// 移除第一个元素值
printVector(v1);v1.erase(v1.begin(), v1.end());// 移除所有元素值
printVector(v1);
v1.clear();// 清空vector
printVector(v1);}//vector存取
void test08() {
vectorint v1;
// 向v1中存值
for (int i 0; i 5; i) {
v1.push_back(i);
}
// 通过数组下标的形式取值
for (int i 0; i 5; i) {
cout v1[i] ;
}
cout endl;
// 通过at()函数进行取值
for (int i 0; i v1.size(); i) {
cout v1.at(i) ;
}
cout endl;
// 取出第一个值和最后一个值
cout v1的第一元素为 v1.front() endl;
cout v1的最后一个元素 v1.back() endl;
}
// 交换两个vector的值
void test09() {
vectorint v1;
for (int i 0; i 5; i) {
v1.push_back(i);
}
printVector(v1);vectorint v2;
for (int i 10; i 0; i--) {
v2.push_back(i);
}
printVector(v2);v1.swap(v2);// 交换vector的值
printVector(v1);
printVector(v2);
}void test10() {
vectorint v1;
v1.reserve(10000);// 数据量比较大开始使用reserve()预留空间
int num 0;
int *p NULL;
for (int i 0; i 10000; i) {
v1.push_back(i);
if (p ! v1[0]) {
p v1[0];
num;
}
}
cout num num endl;
}
int main()
{test01();
test02();
test03();
test04();
test05();
test06();
test07();
test08();
test09();
test10();system(pause);
return 0;
}2.string
#includeiostream
#includealgorithm
#includevector
#includestring
using namespace std;void test01()
{
string s1;// 创建空的字符串调用无参数构造函数
cout s1 endl;const char* str hello world;
string s2(str);// 将字符指针调用
cout s2 endl;string s3(s2);// 用str初始化string
cout s3 endl;string s4(10, a);// 使用10个a字符初始化字符s4
cout s4 endl;
}// 给string赋值
void test02()
{
string str1;
str1 hello world!;
cout str1 endl;string str2;
str2 str1;
cout str2 endl;string str3;
str3 a;
cout str3 endl;string str4;
str4.assign(hello c);
cout str4 endl;string str5;
str5.assign(hello c, 5);// 存取前5个字符
cout str5 endl;
cout str5 endl;string str6;
str6.assign(str5, 2);// 传入的是string对象是去掉前2个字符
cout str6 endl;string str7;
str7.assign(5, x);
cout str7 endl;
}// string拼接
void test03() {
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 );
str3.append(game abcd, 4);// 取前4个字符赋值
cout str3 str3 endl;
str3.append(str2, 4, 2);// 取第4个位置开始的2个元素赋值
cout str3 str3 endl;
}// 查找
void test04() {
string str1 abcdedefg;
int pos str1.find(de);// 开始从起始位置查找第一次出现的下标
if (pos -1) {
cout 未找到 endl;
}
else {
cout pos pos endl;
}pos str1.rfind(de);// 查找最后一次出现的下标
cout pos pos endl;}//string 存取
void test05() {
string str hello world;
for (int i 0; i str.size(); i) {
cout str[i];
}
cout endl;
for (int i 0; i str.size(); i) {
cout str.at(i);
}
cout endl;
}// 插入和删除
void test06() {
string str hello;
str.insert(1, 111);
cout str endl;str.erase(1, 3);// 删除从下标1开始的3个元素
cout str endl;
}// 子串
void test07() {
string str abcdefg;
string substr str.substr(1, 3);
cout substr substr endl;string email hello worldsina.com;
int pos email.find();
string username email.substr(0, pos);
cout username: username endl;
}
int main()
{
//test01();
//test02();
//test03();
//test04();
//test05();
//test06();
test07();
system(pause);
return 0;
}3. deque
双端数组
#includeiostream
#includealgorithm
#includedequeusing namespace std;/*
deque容器双端数组可以对头端进行插入和删除操作
deque和vector区别
vector对于头部的删除插入效率底deque相对较快
vector对元素的访问速度比deque快
deque容器的迭代器支持随机访问
*/
void printDeque(const dequeint d) {
for (dequeint::const_iterator it d.begin(); it ! d.end(); it) {
cout *it ;
}
cout endl;
}
// 构造函数
void test01(){
dequeint d1;
for (int i 0; i 5; i) {
d1.push_back(i);
}printDeque(d1);dequeint d2(d1.begin(), d1.end());
printDeque(d2);dequeint d3(10, 100);
printDeque(d3);dequeint d4 d3;
printDeque(d4);dequeint d5;
d5.assign(10, 100);// 在开始的位置赋值10个100
printDeque(d5);dequeint d6;
d6.assign(d5.begin(), d5.end());
}// 容量大小
void test02() {
dequeint d1;
for (int i 0; i 5; i) {
d1.push_back(i);
}
printDeque(d1);// 判断元素时候是否为空
if (d1.empty()) {
cout d1为空! endl;
}
else {
cout d1的大小为 d1.size() endl;
}
d1.resize(15, 1);// 重新设定大小超过元素使用1填充
printDeque(d1);d1.resize(5);// 重设大小超过部分将被删除
printDeque(d1);}
// 插入和删除
void test03() {
dequeint d;
d.push_back(10);// 尾插
d.push_back(20);d.push_front(100);// 头插
d.push_front(200);printDeque(d);d.pop_back();// 返回最后一个元素
d.pop_front();// 返回第一个元素
printDeque(d);d.insert(d.begin(), 1000);// 在开始的位置插入1000
printDeque(d);
d.insert(d.begin(), 2, 10000);// 在开始的位置插入2个1000
printDeque(d);dequeint d2;
d2.push_back(1);
d2.push_back(2);
d2.push_back(3);
d.insert(d.begin(), d2.begin(), d2.end());// 向d中插入d2的所有值
printDeque(d);d.erase(d.begin());// 删除最开始的元素返回下一个元素的位置d.clear();// 清空d包括删除size
}// 存取值
void test04() {
dequeint d;
d.push_back(10);
d.push_back(20);
d.push_back(30);
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 front d.front() endl;
cout back d.back() endl;
}// 排序升序
void test05() {
dequeint d;
d.push_back(10);
d.push_back(20);
d.push_back(19);
d.push_back(15);
d.push_back(9);
printDeque(d);sort(d.begin(), d.end());
printDeque(d);}
int main()
{//test01();
//test02();
//test03();
//test04();
test05();
system(pause);
return 0;
}4. stack
4.1 常用函数
push()// 入栈 pop()// 出栈 top()// 返回栈顶元素 empty()// 判断栈顶是否为空 size()// 栈中元素
#includeiostream
#includealgorithm
#includestackusing namespace std;void test01() {
stackint s;s.push(10); // 进栈
s.push(20);
s.push(30);while (!s.empty()) { // 判断栈是否为空
cout 栈顶元素 s.top() endl;
s.pop();// 输出栈顶元素
}
cout 栈的大小 s.size() endl;
}
int main()
{
test01();
system(pause);
return 0;
}5. queue
5.1 特点
一端新增元素一端移除元素 只有队头和队尾可以被外界使用队列不允许有遍历行为
5.2 方法
push() // 往队尾添加元素 pop()// 从队头移除第一个元素 back()// 返回最后一个元素 front()// 返回第一个元素 empty()// 判断是否为空 size()// 返回栈的大小
#includeiostream
#includealgorithm
#includestring
#includequeueusing namespace std;/*
队列先进先出允许一端新增元素一端移除元素
队列中只有队头和队尾被外界使用队列不存在遍历行为*/
class Person {
public:
Person(string name, int age) {// 构造函数
this-mName name;
this-mAge age;
}
string mName;
int mAge;
};void test01() {
queuePerson q;Person p1(唐僧, 30);
Person p2(孙悟空, 40);
Person p3(猪八戒, 50);
Person p4(沙僧, 60);q.push(p1);
q.push(p2);
q.push(p3);
q.push(p4);while (!q.empty()) {
// 输出队头元素
cout 姓名: q.front().mName 年龄: q.front().mAge endl;// 输出队尾元素
cout 姓名 q.back().mName 年龄 q.back().mAge endl;
cout endl;
q.pop();
}
cout 队列大小为q.size() endl;}int main()
{
test01();
system(pause);
return 0;
}6. list
链表是一个双向循环链表
6.1 优点
采用动态存储分配不会造成内存浪费和溢出插入和删除操作方便
6.2 缺点
遍历效率低下
6.3 构造函数
list L2(L1.begin(),L1.end())// 将L1链表中的值赋给L1 list L3(10,1000)//存放10个1000 list L4() L4.assign()//存放10个1000
6.4 交换
swap()//交换两个list中的值
6.5 大小
empty()//判断是否为空 size()//输出大小元素个数 resize()//设置大小超过原有数组用0填充未达到则后面的将被删除
6.6 插入和删除
push_back()// 尾插入 push_front()// 头插入 pop_back()// 尾删除 pop_front()// 头删除
insert(it)// it是一个指针 erase(it)// it是一个指针 remove(1000)// 移除list中所有的1000
6.7 排序和反转
reverse()// 反转数组 sort()// 排序数组
在自定义对象例如Person存储到list中需要指定排序的顺序
#includeiostream
#includealgorithm
#includestring
#includelistusing namespace std;
/*
STL中的链表是一个双向循环链表
优点
采用动态存储分配不会造成内存浪费和溢出
插入和删除操作十分方便
缺点
遍历效率低下
*/void printList(const listint L) {
for (listint::const_iterator it L.begin(); it ! L.end(); it) {
cout *it ;
}
cout endl;
}// 构造
void test01() {listint L1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);printList(L1);listintL2(L1.begin(), L1.end());// 构造函数定义的是否进行赋值
printList(L2);listint L3(10, 1000);// 存放10个1000
printList(L3);
}
// 赋值
void test02() {
listint L1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);
printList(L1);listintL2;
L2 L1;
printList(L2);listintL3;
L3.assign(L2.begin(), L2.end());
printList(L3);listintL4;
L4.assign(10, 1000);
printList(L4);
}
// 交换
void test03() {
listintL1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);
printList(L1);listintL2;
L2.assign(10, 1000);
printList(L2);L2.swap(L1);// 交换printList(L1);
printList(L2);}
// 大小操作
void test04() {listint L1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);
printList(L1);if (L1.empty()) {
cout 不为空 endl;
}
else {
cout L1的大小 L1.size() endl;
}// 重新指定大小
L1.resize(10);// 设置大小超过的用0填充
printList(L1);
L1.resize(2);// 除掉后面超过的长度
printList(L1);}// 插入和删除
void test05() {
listint L1;
// 尾插
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);// 头插
L1.push_front(1);
L1.push_front(2);
L1.push_front(3);
L1.push_front(4);
printList(L1);// 尾删
L1.pop_back();
printList(L1);// 头删
L1.pop_front();
printList(L1);// 插入
listint::iterator it L1.begin();
L1.insert(it, 100);
printList(L1);
// 删除
it L1.begin();
L1.erase(it);
printList(L1);// 移除
L1.push_back(1000);
L1.push_back(1000);
L1.push_back(1000);
printList(L1);
L1.remove(1000);
printList(L1);// 清空
L1.clear();
printList(L1);}
// 数据存储
void test06() {
listint L1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(30);
L1.push_back(40);cout 第一个元素 L1.front() endl;
cout 最后一个元素 L1.back() endl;// list中的迭代器是双向迭代器不支持随机访问
// it it 1;是错的}// list反转和排序
void test07() {
listint L1;
L1.push_back(10);
L1.push_back(20);
L1.push_back(4);
L1.push_back(2);
L1.push_back(1);
L1.push_back(30);
L1.push_back(40);
printList(L1);L1.reverse();// 反转链表
printList(L1);L1.sort();// 排序按升序进行
printList(L1);
}// 实例
class Person{
public:
Person(string name, int age, int height) {
m_name name;
m_age age;
m_height height;
}
public:
string m_name;
int m_age;
int m_height;
};
// 指定排序规则
bool comparePerson(Person p1, Person p2) {
if (p1.m_age p2.m_age) {
return p1.m_height p2.m_height;
}
else {
return p1.m_age p2.m_age;
}
}void test08() {
listPersonL1;
Person p1(刘备, 24, 175);
Person p2(关羽, 23, 185);
Person p3(关羽, 22, 185);
Person p4(关羽, 21, 185);
Person p5(张飞, 21, 170);
Person p6(曹操, 19, 165);
Person p7(典韦, 23, 190);L1.push_back(p1);
L1.push_back(p2);
L1.push_back(p3);
L1.push_back(p4);
L1.push_back(p5);
L1.push_back(p6);
L1.push_back(p7);for (listPerson::iterator it L1.begin(); it ! L1.end(); it) {
cout 姓名 it-m_name 年龄 it-m_age 身高: it-m_height endl;
}
cout ---------------------------------------- endl;
L1.sort(comparePerson);
for (listPerson::iterator it L1.begin(); it ! L1.end(); it) {
cout 姓名 it-m_name 年龄 it-m_age 身高: it-m_height endl;
}
}
int main()
{
//test01();
//test02();
//test03();
test04();
//test05 ();
//test06();
//test07();
//test08();
system(pause);
return 0;
}7. set
7.1 方法
inser() // 排除重复元素 empty()// 判断是否为空 size()// 大小 swap()// 交换两个set的元素 erase(s.begin())// 移除最开始的元素 erase(10)// 移除set集合中的10 clear()// 清空set此时size()为0
set::iterator pos s.find(1);// 在元素中进行查找成功后返回位置 s.count(10)// 统计10出现的次数
7.2 pair 对数创建
void test07() { pairstring, int p(string(“Tom”), 20);
cout 姓名 p.first 年龄 p.second endl;
pairstring, int p2 make_pair(“Jerry”, 10); cout 姓名 p2.first 年龄 p2.second endl;
}
7.3 排序
sort()// 默认升序排序 可以根据自己定义的规则进行排序定义一个类
#includeiostream
#includealgorithm
#includeset
#includestring
using namespace std;
/*
set
所有元素都会插入时进行自动排序属于关联式容器底层使用二叉树实现
set不允许容器中有重复元素multiset容器允许有重复元素
*/void printSet(setint s) {
for (setint::iterator it s.begin(); it ! s.end(); it) {
cout *it ;
}
cout endl;
}// 赋值和构造函数
void test01() {
setint s1;
s1.insert(10);
s1.insert(30);
s1.insert(20);
s1.insert(50);
s1.insert(40);
s1.insert(60);
s1.insert(60);
s1.insert(60);
printSet(s1);//赋值
setint s2;
s2 s1;
printSet(s2);// 构造函数
setint s3(s2);
printSet(s3);}// 大小
void test02() {
setint s1;
s1.insert(120);
s1.insert(10);
s1.insert(20);
s1.insert(40);
s1.insert(720);if (s1.empty()) {
cout s1为空 endl;
}
else {
cout s1的大小为 s1.size() endl;
}}
// 交换
void test03() {
setint s1;
s1.insert(12);
s1.insert(2);
s1.insert(10);
s1.insert(23);
s1.insert(1);setint s2;
s2.insert(5);
s2.insert(4);
s2.insert(3);
s2.insert(2);
s2.insert(1);cout 交换前 endl;
printSet(s1);
printSet(s2);
cout 交换后 endl;
s1.swap(s2);
printSet(s1);
printSet(s2);}
// 插入和删除
void test04() {setint s1;
s1.insert(12);
s1.insert(2);
s1.insert(29);
s1.insert(22);
s1.insert(19);
printSet(s1);// 删除
s1.erase(s1.begin());// 删除第一个元素
printSet(s1);s1.erase(19);// 移除素值为19的元素
printSet(s1);// 清空
s1.clear();
printSet(s1);
}// 查找与统计
void test05() {
setint s;
s.insert(12);
s.insert(9);
s.insert(11);
s.insert(2);
s.insert(1);setint::iterator pos s.find(1);
if (pos ! s.end()) {
cout 找到了元素 *pos endl;
}
else {
cout 未找到元素 endl;
}
int num s.count(9);
cout num num endl;
}
void test06() {
setint s;
pairsetint::iterator, bool ret s.insert(12);
if (ret.second) {
cout 第一次插入成功 endl;
}
else {
cout 第一次插入失败 endl;
}ret s.insert(12);
if (ret.second) {
cout 第二次插入成功 endl;
}
else {
cout 第二次插入失败 endl;
}cout ---------------------------------------- endl;
// multiset
multisetint ms;
ms.insert(10);
ms.insert(10);
for (multisetint::iterator it ms.begin(); it ! ms.end(); it) {
cout *it endl;
}
cout endl;
}// pair对数创建
void test07() {
pairstring, int p(string(Tom), 20);cout 姓名 p.first 年龄 p.second endl;pairstring, int p2 make_pair(Jerry, 10);
cout 姓名 p2.first 年龄 p2.second endl;}
// 排序
class MyCompare {
public:
bool operator()(int v1, int v2) {
return v1 v2;
}
};
void test08() {
setint s1;
s1.insert(10);
s1.insert(40);
s1.insert(20);
s1.insert(12);
s1.insert(19);
printSet(s1);setint, MyCompare s2;// 降序排序
s2.insert(10);
s2.insert(14);
s2.insert(1);
s2.insert(100);
s2.insert(23);
s2.insert(45);
for (setint, MyCompare::iterator it s2.begin(); it ! s2.end(); it) {
cout *it ;
}
cout endl;}// set存放自定义数据类型
class Person {
public:string m_name;
int m_age;
Person(string name, int age) {
this-m_name name;
this-m_age age;
}};class comparePerson {
public:
bool operator()(const Person p1, const Person p2) {
// 按照年龄进行降序
return p1.m_age p2.m_age;
}
};void test09() {
setPerson, comparePerson s;// 指定了set中的排序方式
Person p1(刘备, 23);
Person p2(曹操, 22);
Person p3(张飞, 21);
Person p4(关羽, 21);s.insert(p1);
s.insert(p2);
s.insert(p3);
s.insert(p4);for ( setPerson, comparePerson::iterator it s.begin(); it ! s.end(); it){
cout 姓名 it-m_name 年龄 it-m_age endl;
}
}
int main()
{
//test01();
//test02();
//test03();
//test04();
//test05();
//test06();
//test07();
//test08();
test09();
system(pause);
return 0;
}8. map
map中所有元素为pair第一个键第二个为值 所有元素根据元素的键值自动排序 属于关联式容器底层由二叉树实现
map不允许容器中所有重复key值 multimap允许容器中重复key值
8.1 插入元素大小与交换
insert(pairint,int(1,10))// 插入键值对 empty()判断是否为空 size()拥有多少键值对 swap()交换两个map中的键值对
8.2 查找与统计
mapint,int::iterator pos m.find(3)// 查找map中键为3的键的位置 count(3)// 统计键为3的键值对个数
8.3 排序
按照key值进行从小到大的排序 利用仿函数能够改变排序的规则
#includeiostream
#includealgorithm
#includemap
#includestring
using namespace std;
/*
map中所有元素为pair,第一个元素为键第二个为元素
所有元素根据元素的键值自动排序
属于关联式容器底层由二叉树实现map不允许容器中有重复key值
multimap允许容器中重复key值
*/
void printMap(mapint, int m) {
for (mapint, int::iterator it m.begin(); it ! m.end(); it) {
cout key it-first value it-second endl;
}
cout endl;
}
void test01() {mapint, int m;// 默认构建
m.insert(pairint, int(1, 10));
m.insert(pairint, int(2, 20));
m.insert(pairint, int(3, 30));
m.insert(pairint, int(4, 40));
printMap(m);mapint, int m2(m);// 拷贝函数
printMap(m2);mapint, int m3;
m3 m2;// 赋值
printMap(m3);}// 大小与交换
void test02() {
mapint, int m;
m.insert(pairint, int(1, 10));
m.insert(pairint, int(2, 20));
m.insert(pairint, int(3, 30));
m.insert(pairint, int(4, 40));
if (m.empty()) {
cout m为空 endl;
}
else {
cout m不为空 endl;
cout m的大小为 m.size() endl;
}mapint, int m1;
m1.insert(pairint, int(10, 100));
m1.insert(pairint, int(20, 200));
m1.insert(pairint, int(30, 300));
m1.insert(pairint, int(40, 400));
cout 交换前 endl;
printMap(m);
printMap(m1);
cout ----------------------------------- endl;
cout 交换后 endl;
m.swap(m1);
printMap(m);
printMap(m1);
}// 插入和删除
void test03() {
mapint, int m;
//第一种插入
m.insert(pairint, int(1, 10));
//第二种插入
m.insert(make_pair(2, 20));
//第三种插入
m.insert(mapint, int::value_type(3, 30));
//第四种插入
m[4] 40;printMap(m);m.erase(m.begin());// 删除最开始的元素
m.erase(3);// 删除键值为3的对数
printMap(m);// 清空
m.erase(m.begin(), m.end());
printMap(m);}//查找与统计
void test04() {
mapint, int m;
m.insert(pairint, int(1, 10));
m.insert(pairint, int(2, 20));
m.insert(pairint, int(3, 30));
m.insert(pairint, int(4, 40));// 查找
mapint, 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;// 统计键值为3出现的次数
}// 排序
// 按照key值进行从小到大的排序
// 利用仿函数能够改变排序的规则
class MyCompare {
public:
bool operator()(int v1, int v2) {
return v1 v2;
}
};void test05() {
mapint, int, MyCompare m;// 在这里会作降序排序
m.insert(make_pair(1, 10));
m.insert(make_pair(3, 30));
m.insert(make_pair(2, 20));
m.insert(make_pair(6, 60));
m.insert(make_pair(5, 50));for (mapint, int, MyCompare::iterator it m.begin(); it ! m.end(); it) {
cout key: it-first value: it-second endl;
}
}
int main()
{
//test01();
//test02();
//test03();
//test04();
test05();
system(pause);
return 0;
}
