本片为提高篇

1、模板

1.1、函数模板

模板的特点：

模板不可以直接使用，它只是一个框架
模板的通用并不是万能的
C++另一种编程思想称为泛型编程，主要利用的技术就是模板
C++提供两种模板机制:函数模板和类模板

函数模板作用：建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。

template 函数声明或定义
解释：
template — 声明创建模板
typename — 表面其后面的符号是一种数据类型，可以用class代替
T — 通用的数据类型，名称可以替换，通常为大写字母

#include <iostream>
using namespace std;/*
模板特点：
1、模板不可以直接使用，它只是一个框架
2、模板的通用并不是万能的
*//*比如：简单的交换函数*/
void intSwap(int& a, int& b)
{int temp;temp = a;a = b;b = temp;
}
void doubleSwap(double& a, double& b)
{double temp;temp = a;a = b;b = temp;
}
//使用函数模板
template <typename T>
void Swap(T& a, T& b)
{T temp;temp = a;a = b;b = temp;
}
template <typename T>
void func()
{cout << "func()函数调用" << endl;
}template <typename T>
void arrsork(T arr[], int& len)
{int i, j;for (int i = 0; i < len; i++){for (int j = i; j < len; j++){if (arr[i] > arr[j]){Swap(arr[i], arr[j]);}}}
}template <typename T>
T addtest(T a, T b)
{return a + b;
}void mytemplate(void)
{int a = 56;int b = 89;char c = 40;int arr[10] = { 4,58,1,0,89,56854,4568,23,56,40 };int arrint = sizeof(arr)/sizeof(int);//   intSwap(a, b);//两种方式//1、自动类型推导--必须推导出一致的数据类型T,才可以使用Swap(a, b);//正确--可以推导出一直的T类型addtest<int>(a, c);//显示指定类型--//  Swap(a, c);//错误--推导不出一致的T类型//2、显示指定类型--模板必须要确定出T的数据类型，才可以使用Swap<int>(a, b);cout << "a = " << a << endl;cout << "b = " << b << endl;addtest<int>(a, c);//显示指定类型--可以发生隐藏式类型转换//func(); //错误，模板不能独立使用，必须确定出T的类型 func<int>(); //利用显示指定类型的方式，给T一个类型，才可以使用该模板arrsork(arr, arrint);for (int i = 0; i < 10; i++){cout << arr[i] << " ";}cout << endl;
}

总结：

函数模板利用关键字 template
使用函数模板有两种方式：自动类型推导、显示指定类型
模板的目的是为了提高复用性，将类型参数化

注意事项

自动类型推导，必须推导出一致的数据类型T,才可以使用
模板必须要确定出T的数据类型，才可以使用
使用模板时必须确定出通用数据类型T，并且能够推导出一致的类型

普通函数与函数模板区别：

普通函数调用时可以发生自动类型转换（隐式类型转换）
函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
如果利用显示指定类型的方式，可以发生隐式类型转换

建议使用显示指定类型的方式，调用函数模板，因为可以自己确定通用类型T

调用规则如下：

如果函数模板和普通函数都可以实现，优先调用普通函数
可以通过空模板参数列表来强制调用函数模板
函数模板也可以发生重载
如果函数模板可以产生更好的匹配,优先调用函数模板

#include <iostream>
using namespace std;/*
1. 如果函数模板和普通函数都可以实现，优先调用普通函数
2. 可以通过空模板参数列表来强制调用函数模板
3. 函数模板也可以发生重载
4. 如果函数模板可以产生更好的匹配,优先调用函数模板
*/
//普通函数
int func1(int &a,int &b)
{cout << "普通函数func1--调用" << endl;return a + b;
}
//函数模板
template <typename T>
T func1(T& a, T& b)
{cout << "函数模板func2--调用" << endl;return a + b;
}
template <typename T>
T func1(T& a, T& b, T& c)
{cout << "重载函数模板func2--调用" << endl;return a + b + c;
}
void Callrules(void)
{int a = 89;int b = 11;int c = 50;//普通函数cout << "func1 = " << func1(a, b) << endl;//函数模板--可以通过空模板参数列表来强制调用函数模板cout << "func1 = " << func1<>(a, b) << endl;//调用重载的函数模板cout << "func1 = " << func1<>(a, b, c) << endl;
}

注意：：：：既然提供了函数模板，最好就不要提供普通函数，否则容易出现二义性

模板的局限性
局限性：
模板的通用性并不是万能的

#include <iostream>
using namespace std;template <class T>
bool func01(T a, T b)
{if (a == b){return true;}else{return false;}
}class person
{public:person(string name, int age){this->name = name;this->age = age;}
public:string name;int age;
};
/*
在上述代码中，如果T的数据类型传入的是像Person这样的自定义数据类型，也无法正常运行
因此C++为了解决这种问题，提供模板的重载，可以为这些特定的类型提供具体化的模板
*///具体化，显示具体化的原型和定意思以template<>开头，并通过名称来指出类型
//具体化优先于常规模板
template<> bool func01(person p1, person p2)
{if (p1.name == p2.name && p1.age == p2.age){return true;}else{return false;}
}
void boundedness(void)
{int a = 45;int b = 96;person p1("王二毛", 45);person p2("王二毛", 45);bool ret;ret = func01(a, b);if (ret)cout << "a == b" << endl;elsecout << "a != b" << endl;ret = func01(p1, p2);if (ret)cout << "p1 == p2" << endl;elsecout << "p1 != p2" << endl;
}

总结：

利用具体化的模板，可以解决自定义类型的通用化
学习模板并不是为了写模板，而是在STL能够运用系统提供的模板

1.2、类模板

1.2.1、类模板基本应用

类模板作用：
建立一个通用类，类中的成员数据类型可以不具体制定，用一个虚拟的类型来代表。
语法：template 类
解释：

template — 声明创建模板
typename — 表面其后面的符号是一种数据类型，可以用class代替
T — 通用的数据类型，名称可以替换，通常为大写字母

#include <iostream>
using namespace std;template <typename Typename, typename Typeage>
class person01
{public:person01(Typename name,Typeage age){this->name = name;this->age = age;}void show(){cout << "姓名：" << name << endl;cout << "年龄：" << age << endl;}
public:Typename name;Typeage age;
};void classtemplate(void)
{// 指定TypeName 为string类型，TypeAge 为 int类型person01<string, int>p1("大壮",52);p1.show();
}

1.2.2、类模板与函数模板区别

类模板与函数模板区别主要有两点：

类模板没有自动类型推导的使用方式
类模板在模板参数列表中可以有默认参数

#include <iostream>
using namespace std;template <class Typename, class Typeage = int>
class person02
{public:person02(Typename name, Typeage age){this->name = name;this->age = age;}void show(){cout << "姓名：" << name << endl;cout << "年龄：" << age << endl;}
public:Typename name;Typeage age;
};2、类模板在模板参数列表中可以有默认参数
void classtemplate01(void)
{// 指定TypeName 为string类型，TypeAge 为 int类型person02 <string> p1("小壮", 999);//类模板中的模板参数列表 可以指定默认参数       p1.show();
}

总结：

类模板使用只能用显示指定类型方式
类模板中的模板参数列表可以有默认参数
总结：类模板和函数模板语法相似，在声明模板template后面加类，此类称为类模板

1.2.3、类模板中成员函数创建时机

类模板中成员函数和普通类中成员函数创建时机是有区别的：

普通类中的成员函数一开始就可以创建
类模板中的成员函数在调用时才创建

#include <iostream>
using namespace std;
class person03
{public:person03(){cout << "person03---无参构造函数" << endl;}void show03(){cout << "person03---show03函数调用" << endl;}
};
class person04
{public:person04(){cout << "person04---无参构造函数" << endl;}void show04(){cout << "person04---show04函数调用" << endl;}
};
template <class T>
class person05
{public:person05(){cout << "person05---无参构造函数" << endl;}
//类模板中的成员函数，并不是一开始就创建的，而是在模板调用时再生成void func1(){name.show03();}void func2(){name.show04();}
public:T name;
};
2、类模板在模板参数列表中可以有默认参数
void classtemplate02(void)
{cout << 89898989 << endl;// 指定TypeName 为string类型，TypeAge 为 int类型person05 <person03> p1;//类模板中的模板参数列表 可以指定默认参数 cout << 8989898888989899 << endl;p1.func1();//p1.func2();//编译会出错，说明函数调用才会去创建成员函数
}
//总结：类模板中的成员函数并不是一开始就创建的，在调用时才去创建

1.2.4、类模板对象做函数参数

一共有三种传入方式：

指定传入的类型 — 直接显示对象的数据类型
参数模板化 — 将对象中的参数变为模板进行传递
整个类模板化 — 将这个对象类型模板化进行传递

#include "iostream"
using namespace std;//3种方式
//1：指定传入类型---直接显示对象的数据类型
//2：参数模板化-----将对象的参数变为模板进行传递
//3：整个类模板化---将这个对象类型模板化进行传递template <class Typename,class Typeage>
class person06
{public:person06(Typename name,Typeage age){this->name = name;this->age = age;}void showmassage(){cout << "name = " << name << endl;cout << "age = " << age << endl;}public:Typename name;Typeage age;
};//指定传入类型
void func1_person06(person06<string, int>& p)
{p.showmassage();
}//参数模板化
template <class T1,class T2>
void func2_person06(person06<T1, T2>& p)
{p.showmassage();cout << "T1的类型为： " << typeid(T1).name() << endl;cout << "T2的类型为： " << typeid(T2).name() << endl;
}//整个类模板化
template <class T>
void func3_person06(T & p)
{p.showmassage();cout << "T的类型为： " << typeid(T).name() << endl;
}void classmakefuncpara(void)
{person06 <string, int>p1("王一毛", 20);person06 <string, int>p2("王二毛", 30);person06 <string, int>p3("王三毛", 40);func1_person06(p1);func2_person06(p2);func3_person06(p3);
}

总结：
1、通过类模板创建的对象，可以有三种方式向函数中进行传参
2、使用比较广泛是第一种：指定传入的类型

1.2.5、类模板与继承

当类模板碰到继承时，需要注意一下几点：

当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型
如果不指定，编译器无法给子类分配内存
如果想灵活指定出父类中T的类型，子类也需变为类模板

#include "iostream"
using namespace std;/*
当类模板碰到继承时，需要注意一下几点：
1、当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型
2、如果不指定，编译器无法给子类分配内存
3、如果想灵活指定出父类中T的类型，子类也需变为类模板
*/template <class T>
class base01
{public:base01(){cout << "类模板与继承---父类--有参构造函数" << endl;/*  this->name = name;*/}void show(){cout << "父类--姓名：" << this->name << endl;}
public:T name;
};//子类继承-要指定出父类中T的类型
class son1 :public base01<string>
{public:son1(string name){cout << "类模板与继承---子类son1--有参构造函数" << endl;this->name = name;}void show(){cout << "子类son1--姓名：" << this->name << endl;}
};template <class T1,class T2>
class son2 :public base01<T2>
{public:son2(int age){cout << "类模板与继承---子类son2--有参构造函数" << endl;this->age = age;}void show(){cout << "子类son2--姓名：" << this->name << endl;cout << "子类son2--年龄：" << this->age << endl;}
public:T1 age;
};void classandinherit(void)
{son1 s1("大锤");
//  s1.base01::name = "7787987";s1.base01::show();s1.show();son2<int,string>s2(89);s2.name = "阿三";s2.base01<string>::name = "fsfsf";//访问父类模板的成员（函数或者变量），需要加上<string>参数列表s2.base01<string>::show();s2.show();}

总结：如果父类是类模板，子类需要指定出父类中T的数据类型

1.2.6、类外声明类模板的成员函数

#include "iostream"
using namespace std;/*学习目标：能够掌握类模板中的成员函数类外实现*/template <class T1,class T2>
class person07
{public:person07(T1 name, T2 age);void showinfo();public:T1 name;T2 age;
};
template<class T1,class T2>
person07<T1, T2>::person07(T1 name, T2 age)
{this->name = name;this->age = age;
}template<class T1,class T2>
void person07<T1, T2>::showinfo()
{cout << "姓名：" << this->name << endl;cout << "年龄：" << this->age << endl;
}void classoutsta(void)
{person07<string,int> p1("迷糊",25);p1.showinfo();
}

1.2.7、类模板与友元

全局函数类内实现 - 直接在类内声明友元即可
全局函数类外实现 - 需要提前让编译器知道全局函数的存在

#include "iostream"
using namespace std;
/*
两种方式：
1、类内实现---常用、比较简单、编译器可以直接识别
2、类外实现
*/template <class T1, class T2>class person08;//全局函数配合友元 类外实现 - 先做类模板声明、函数声明、下方再做函数模板定义，再做友元template <class T1,class T2>
void personfriend02(person08<T1, T2>& p)//类外全局函数做友元---要提前声明类
{cout << "类外实现友元--姓名：" << p.name << "--年龄：" << p.age << endl;
}template <class T1,class T2>
class person08
{//类内实现friend void personfriend01(person08<T1, T2>& p){cout << "类内实现友元--姓名：" << p.name << "--年龄：" << p.age << endl;}//类外实现friend void personfriend02<>(person08<T1, T2>& p);public:person08(T1 name, T2 age);void showinfo();
private:T1 name;T2 age;
};template <class T1,class T2>
person08<T1, T2>::person08(T1 name, T2 age)
{this->name = name;this->age = age;
}
template <class T1,class T2>
void person08<T1, T2>::showinfo()
{cout << "姓名：" << this->name << endl;cout << "年龄：" << this->age << endl;
}
void classandfriend(void)
{//类内友元--实现person08<string, int> p1("联合国", 89);p1.showinfo();personfriend01(p1);//类外友元--实现person08<string, int> p2("黑寡妇", 784);p2.showinfo();personfriend02(p2);
}

2、STL初识

2.1、基本概念

STL(Standard Template Library,标准模板库)
STL 从广义上分为: 容器(container) 算法(algorithm) 迭代器(iterator)
容器和算法之间通过迭代器进行无缝连接。
STL 几乎所有的代码都采用了模板类或者模板函数

STL大体分为六大组件，分别是:容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器

容器：各种数据结构，如vector、list、deque、set、map等,用来存放数据。
算法：各种常用的算法，如sort、find、copy、for_each等 3. 迭代器：扮演了容器与算法之间的胶合剂。
仿函数：行为类似函数，可作为算法的某种策略。
适配器：一种用来修饰容器或者仿函数或迭代器接口的东西。
空间配置器：负责空间的配置与管理。

容器：置物之所也
STL容器就是将运用最广泛的一些数据结构实现出来

常用的数据结构：数组, 链表,树, 栈, 队列, 集合, 映射表等

这些容器分为序列式容器和关联式容器两种:

序列式容器:强调值的排序，序列式容器中的每个元素均有固定的位置。
关联式容器:二叉树结构，各元素之间没有严格的物理上的顺序关系

算法：问题之解法也
有限的步骤，解决逻辑或数学上的问题，这一门学科我们叫做算法(Algorithms)
算法分为:质变算法和非质变算法。

质变算法：是指运算过程中会更改区间内的元素的内容。例如拷贝，替换，删除等等
非质变算法：是指运算过程中不会更改区间内的元素内容，例如查找、计数、遍历、寻找极值等等

迭代器：容器和算法之间粘合剂
提供一种方法，使之能够依序寻访某个容器所含的各个元素，而又无需暴露该容器的内部表示方式。
每个容器都有自己专属的迭代器
迭代器使用非常类似于指针，初学阶段我们可以先理解迭代器为指针
迭代器种类：

种类	功能	支持运算
输入迭代器	对数据的只读访问	只读，支持++、==、!、=
输出迭代器	对数据的只写访问	只写、支持++
向前迭代器	读写操作、并能向前推进迭代器	读写、支持++、==、!、=
双向迭代器	读写操作，并能向前和向后操作	读写，支持++、–
随机访问迭代器	读写操作，可以以跳跃的方式访问任意数据，功能最强的迭代器	读写，支持++、–、[n]、-n、<、<=、>、>=

常用的容器中迭代器种类为双向迭代器和随机访问迭代器
例子：

#include <iostream>
using namespace std;#include <vector>
#include <algorithm>void vectorprintf(int val)
{cout << val << " ";
}void vectortest(void)
{//创建vector容器对象，并且通过模板参数指定容器中存放的数据类型vector<int> v;//向容器中存放数据for (int i = 0; i < 10; i++){v.push_back(i * 10);}//每个容器都有自己的迭代器，迭代器是用来遍历容器中的元素的//v.begin()返回迭代器，这个迭代器指向的是容器中第一个数据//v.end()返回迭代器，这个迭代器指向容器元素的最后一个元素的下一个位置//vector<int>::iterator 拿到vector<int>这种容器的迭代器类型//第一种遍历方式vector<int>::iterator pbegin = v.begin();vector<int>::iterator pend = v.end();while (pbegin != pend){cout << *pbegin << " ";pbegin++;}cout << endl;//第二种遍历方式for (vector<int>::iterator it = v.begin(); it < v.end(); it++){cout << *it << " ";}cout << endl;//第三种遍历方式//使用STL提供的标准遍历算法 需要包含头文件 algorithmfor_each(v.begin(), v.end(), vectorprintf);cout << endl;
}

2.2、vector容器嵌套容器

#include <iostream>
using namespace std;#include <vector>class person10
{public:person10(string name, int age){this->name = name;this->age = age;}public:string name;int age;
};
/*
1、person10 类
2、person10* 类
3、vector<int> 类
*/void userdefinedvector(void)
{/*1、person10 类*///创建容器cout << "person10  类部分-----------*****" << endl;vector<person10> v1;//创建容器成员person10 p1("悟空", 2);person10 p2("悟净", 22);person10 p3("悟能", 222);person10 p4("悟傻", 2222);//添加v1.push_back(p1);v1.push_back(p2);v1.push_back(p3);v1.push_back(p4);//打印for (vector<person10>::iterator it = v1.begin(); it != v1.end(); it++){//cout << "姓名：" << (*it).name << " 年龄：" << (*it).age << endl;cout << "姓名：" << it->name << " 年龄：" << it->age << endl;}/*2、person10* 类*/cout << "person10 * 类部分-----------*****" << endl;vector<person10*> v2;person10 p5("哥哥", 5);person10 p6("武松", 55);person10 p7("大朗", 555);person10 p8("金莲", 5555);//添加v2.push_back(&p5);v2.push_back(&p6);v2.push_back(&p7);v2.push_back(&p8);//打印for (vector<person10*>::iterator it = v2.begin(); it != v2.end(); it++){//cout << "姓名：" << (*it).name << " 年龄：" << (*it).age << endl;cout << "姓名：" << (*it)->name << " 年龄：" << (*it)->age << endl;}/*3、vector<int> 类 部分*/cout << "嵌套 vector<int> 类部分-----------*****" << endl;vector <vector<int>> v3;//创建容器成员vector<int> son1;vector<int> son2;vector<int> son3;vector<int> son4;//赋值for (int i = 0; i < 10; i++){son1.push_back(i + 10);son2.push_back(i + 100);son3.push_back(i + 1000);son4.push_back(i + 10000);}//添加到容器中v3.push_back(son1);v3.push_back(son2);v3.push_back(son3);v3.push_back(son4);//打印for (vector < vector<int> >::iterator it = v3.begin(); it != v3.end(); it++){for (vector< int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++){cout << *vit << " ";}cout << endl;}cout << "嵌套 vector<person10> 类部分-----------*****" << endl;vector <vector<person10>> v4;vector<person10> son5;vector<person10> son6;vector<person10> son7;person10 son5_1("aaa", 111);person10 son5_2("bbb", 222);person10 son5_3("ccc", 333);person10 son6_1("ddd", 444);person10 son6_2("eee", 555);person10 son6_3("fff", 666); person10 son7_1("ggg", 777);person10 son7_2("hhh", 888);person10 son7_3("iii", 999);//添加son5.push_back(son5_1);son5.push_back(son5_2);son5.push_back(son5_3);son6.push_back(son6_1);son6.push_back(son6_2);son6.push_back(son6_3);son7.push_back(son7_1);son7.push_back(son7_2);son7.push_back(son7_3);v4.push_back(son5);v4.push_back(son6);v4.push_back(son7);for (vector<vector<person10>>::iterator it = v4.begin(); it != v4.end(); it++){for (vector<person10>::iterator vit = (*it).begin(); vit != (*it).end(); vit++){cout << "姓名：" << vit->name << " 年龄：" << vit->age << endl;}cout << endl;}
}

3、STL-常用容器

3.1、string容器

3.1.1、string赋值操作

string基本概念
本质：string是C++风格的字符串，而string本质上是一个类
string和char * 区别：

char * 是一个指针
string是一个类，类内部封装了char*，管理这个字符串，是一个char*型的容器。

特点：

string 类内部封装了很多成员方法，例如：查找find，拷贝copy，删除delete 替换replace，插入insert
string管理char*所分配的内存，不用担心复制越界和取值越界等，由类内部进行负责

构造函数原型：

string(); //创建一个空的字符串例如: string str;
string(const char* s); //使用字符串s初始化
string(const string& str); //使用一个string对象初始化另一个string对象
string(int n, char c); //使用n个字符c初始化

功能描述：给string字符串进行赋值
赋值的函数原型：

string& operator=(const char* s); //char*类型字符串赋值给当前的字符串
string& operator=(const string &s); //把字符串s赋给当前的字符串
string& operator=(char c); //字符赋值给当前的字符串
string& assign(const char *s); //把字符串s赋给当前的字符串
string& assign(const char *s, int n); //把字符串s的前n个字符赋给当前的字符串
string& assign(const string &s); //把字符串s赋给当前字符串
string& assign(int n, char c); //用n个字符c赋给当前字符串

简单例子：

#include <iostream>
using namespace std;/*
string& operator=(const char* s); //char*类型字符串 赋值给当前的字符串
string& operator=(const string &s); //把字符串s赋给当前的字符串
string& operator=(char c); //字符赋值给当前的字符串
string& assign(const char *s); //把字符串s赋给当前的字符串
string& assign(const char *s, int n); //把字符串s的前n个字符赋给当前的字符串
string& assign(const string &s); //把字符串s赋给当前字符串
string& assign(int n, char c); //用n个字符c赋给当前字符串
*/void stringbase(void)
{string s1;s1.assign("hello world", 5);cout << s1 << endl;s1.assign("5655656");cout << s1 << endl;s1.assign(10, '6');cout << s1 << endl;
}

3.1.2、string字符串拼接

功能描述：

实现在字符串末尾拼接字符串

函数原型：

string& operator+=(const char* str); //重载+=操作符
string& operator+=(const char c); //重载+=操作符
string& operator+=(const string& str); //重载+=操作符
string& append(const char *s); //把字符串s连接到当前字符串结尾
string& append(const char *s, int n); //把字符串s的前n个字符连接到当前字符串结尾
string& append(const string &s); //同operator+=(const string& str)
string& append(const string &s, int pos, int n); //字符串s中从pos开始的n个字符连接到字符串结尾

例子：

#include <iostream>
using namespace std;/*
string& operator+=(const char* str); //重载+=操作符
string& operator+=(const char c); //重载+=操作符
string& operator+=(const string& str); //重载+=操作符
string& append(const char *s); //把字符串s连接到当前字符串结尾
string& append(const char *s, int n); //把字符串s的前n个字符连接到当前字符串结尾
string& append(const string &s); //同operator+=(const string& str)
string& append(const string &s, int pos, int n); //字符串s中从pos开始的n个字符连接到字符串结尾
*///字符串拼接
void stringappend(void)
{string s1 = "我";s1 += "是";cout << s1 << endl;s1 += ':';cout << s1 << endl;string s2 = "王大锤";s1 += s2;cout << s1 << endl;s1.append(",我今年");cout << s1 << endl;s1.append("12568912",2);cout << s1 << endl;s1.append("腻害岁了。", 4, 6);//从第4个字符开始，截取6个字符（注意一个汉字占用两个字符）---拼接到s1尾部cout << s1 << endl;
}

3.1.3、string字符串查找和替换

功能描述：

查找：查找指定字符串是否存在
替换：在指定的位置替换字符串
函数原型：
int find(const string& str, int pos = 0) const; //查找str第一次出现位置,从pos开始查找
int find(const char* s, int pos = 0) const; //查找s第一次出现位置,从pos开始查找
int find(const char* s, int pos, int n) const; //从pos位置查找s的前n个字符第一次位置
int find(const char c, int pos = 0) const; //查找字符c第一次出现位置
int rfind(const string& str, int pos = npos) const; //查找str最后一次位置,从pos开始查找
int rfind(const char* s, int pos = npos) const; //查找s最后一次出现位置,从pos开始查找
int rfind(const char* s, int pos, int n) const; //从pos查找s的前n个字符最后一次位置
int rfind(const char c, int pos = 0) const; //查找字符c最后一次出现位置
string& replace(int pos, int n, const string& str); //替换从pos开始n个字符为字符串str
string& replace(int pos, int n,const char* s); //替换从pos开始的n个字符为字符串s

#include <iostream>
using namespace std;/*
int find(const string& str, int pos = 0) const; //查找str第一次出现位置,从pos开始查找
int find(const char* s, int pos = 0) const; //查找s第一次出现位置,从pos开始查找
int find(const char* s, int pos, int n) const; //从pos位置查找s的前n个字符第一次位置
int find(const char c, int pos = 0) const; //查找字符c第一次出现位置
int rfind(const string& str, int pos = npos) const; //查找str最后一次位置,从pos开始查找
int rfind(const char* s, int pos = npos) const; //查找s最后一次出现位置,从pos开始查找
int rfind(const char* s, int pos, int n) const; //从pos查找s的前n个字符最后一次位置
int rfind(const char c, int pos = 0) const; //查找字符c最后一次出现位置
string& replace(int pos, int n, const string& str); //替换从pos开始n个字符为字符串str
string& replace(int pos, int n,const char* s); //替换从pos开始的n个字符为字符串s
*/void stringfindandreplace(void)
{string str = "abcdefggfedcba";int pos = str.find("de");if (pos == -1)cout << "未找到" << endl;elsecout << "pos = " << pos << endl;//从str字符串的8位置开始查找，查找字符串"abc"前两个字符(ab)在str字符串中出现的位置pos = str.find("cba",8,2);if (pos == -1)cout << "未找到" << endl;elsecout << "pos = " << pos << endl;pos = str.rfind("de"); if (pos == -1)cout << "未找到" << endl;elsecout << "pos = " << pos << endl;//从str字符串的第1个位置开始的后2个字符使用1111进行替换-->a1111defde(也就是把bc替换成1111)str.replace(1,2,"1111");cout << str << endl;
}

3.1.4、string字符串比较

功能描述：字符串之间的比较
比较方式：字符串比较是按字符的ASCII码进行对比

= 返回 0
> 返回 1
< 返回 -1

函数原型：

int compare(const string &s) const; //与字符串s比较
int compare(const char *s) const; //与字符串s比较

#include <iostream>
using namespace std;void stringcmp(void)
{string s1 = "hello"; string s2 = "aello"; int ret = s1.compare(s2); if (ret == 0) { cout << "s1 等于 s2" << endl; }else if (ret > 0) {cout << "s1 大于 s2" << endl;}else{ cout << "s1 小于 s2" << endl;}
}

总结：字符串对比主要是用于比较两个字符串是否相等，判断谁大谁小的意义并不是很大

3.1.5、string存取

string中单个字符存取方式有两种

char& operator[](int n); //通过[]方式取字符
char& at(int n); //通过at方法获取字符

#include <iostream>
using namespace std;void stringgetandsave(void)
{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;//字符修改 str[0] = 'x'; str.at(1) = 'x';cout << str << endl;
}

总结：总结：string字符串中单个字符存取有两种方式，利用 [ ] 或 at

3.1.6、string插入和删除

功能描述：对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个字符

#include <iostream>
using namespace std;void stringinsertanderase(void)
{string str = "hello";str.insert(1, "111");cout << str << endl; str.erase(1, 3); //从1号位置开始删除3个字符 cout << str << endl;
}

总结：插入和删除的起始下标都是从0开始

3.1.7、string子串

功能描述：从字符串中获取想要的子串
函数原型：

string substr(int pos = 0, int n = npos) const; //返回由pos开始的n个字符组成的字符串

#include <iostream>
using namespace std;void stringson(void)
{string str = "abcdefg"; string subStr = str.substr(1, 3);//从1位置开始向后数3个，返回 cout << "subStr = " << subStr << endl; string email = "hello@sina.com"; int pos = email.find("@"); string username = email.substr(0, pos);cout << "username: " << username << endl;
}

3.2、vector容器

3.2.1、 vector构造函数

功能：

vector数据结构和数组非常相似，也称为单端数组

vector与普通数组区别：

不同之处在于数组是静态空间，而vector可以动态扩展

动态扩展：

并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间

vector容器的迭代器是支持随机访问的迭代器

功能描述：

创建vector容器

函数原型：

vector v; //采用模板实现类实现，默认构造函数
vector(v.begin(), v.end()); //将v[begin(), end())区间中的元素拷贝给本身。
vector(n, elem); //构造函数将n个elem拷贝给本身。
vector(const vector &vec); //拷贝构造函数。

#include <iostream>
using namespace std;
#include <vector>/*
vector<T> v; //采用模板实现类实现，默认构造函数
vector(v.begin(), v.end()); //将v[begin(), end())区间中的元素拷贝给本身。
vector(n, elem); //构造函数将n个elem拷贝给本身。
vector(const vector &vec); //拷贝构造函数。
*/
void vectorprintf01(vector<int>&v)
{for (vector<int>::iterator it = v.begin(); it != v.end(); it++){cout << *it << " ";}cout << endl;
}void vectorconstructor(void)
{vector<int> v1;for (int i = 0; i < 10; i++){v1.push_back(i);}vectorprintf01(v1);vector<int >v2(v1.begin(), v1.end());vectorprintf01(v2);vector<int > v3(10, 100); //构造函数将10个100拷贝给本身vectorprintf01(v3);vector<int >v4(v2);vectorprintf01(v4);
}

3.3、deque容器

功能：双端数组，可以对头端进行插入删除操作

deque与vector区别：

vector对于头部的插入删除效率低，数据量越大，效率越低
deque相对而言，对头部的插入删除速度回比vector快
vector访问元素时的速度会比deque快,这和两者内部实现有关

deque内部工作原理:
deque内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据
中控器维护的是每个缓冲区的地址，使得使用deque时像一片连续的内存空间

#include <iostream>
using namespace std;
#include <deque>
#include <algorithm>
void dequeprintf(int dnum, deque<int>& d)
{if (d.empty()){cout << "d" << dnum <<"为空" << endl;return;}cout << "d" << dnum << " = ";for (deque<int>::iterator it = d.begin(); it != d.end(); it++){cout << (*it) << " ";}cout << endl;
}void dequeuse(void)
{//deque<T> deqT; //默认构造形式//deque(beg, end); //构造函数将[beg, end)区间中的元素拷贝给本身。//deque(n, elem); //构造函数将n个elem拷贝给本身。//deque(const deque & deq); //拷贝构造函数cout << endl << "deque构造函数部分" << endl;deque<int> d1;for (int i = 0; i < 10; i++){d1.push_back(i + 10);}dequeprintf(1, d1);deque<int> d2(d1.begin(), d1.end());dequeprintf(2, d2);deque<int> d3(10, 99);dequeprintf(3, d3);deque<int> d4(d3);//或者deque<int> d4 = d3;dequeprintf(4, d4);cout << endl << "deque赋值操作部分" << endl;//deque& operator=(const deque & deq); //重载等号操作符//assign(beg, end); //将[beg, end)区间中的数据拷贝赋值给本身。//assign(n, elem); //将n个elem拷贝赋值给本身。deque<int> d5;d5 = d1;dequeprintf(5, d5);deque<int> d6;d6.assign(d1.begin(), d1.end());dequeprintf(6, d6);deque<int> d7;d7.assign(10, 55);dequeprintf(7, d7);//deque.empty();判断容器是否为空//deque.size();返回容器中元素的个数//deque.resize(num);重新指定容器的长度为num,若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。//deque.resize(num, elem);重新指定容器的长度为num,若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
cout << endl << "deque大小操作部分" << endl;if (d1.empty()){cout << "d1为空" << endl;}else{cout << "d1的大小是：" << d1.size() << endl;}d1.resize(15);//重新指定容器d1的大小cout << "d1的大小是：" << d1.size() << endl;dequeprintf(1,d1);d1.resize(20, 42);//重新指定容器d1的大小,容器变长，变长部分使用42进行填充cout << "d1的大小是：" << d1.size() << endl;dequeprintf(1,d1);//两端插入操作：//push_back(elem); //在容器尾部添加一个数据//push_front(elem); //在容器头部插入一个数据//pop_back(); //删除容器最后一个数据//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位置的数据，返回下一个数据的位置。cout << endl << "deque插入和删除部分" << endl;d1.push_back(7525);//尾插d1.push_front(456);//头插dequeprintf(1, d1);d1.pop_back();//尾删d1.pop_front();//头删dequeprintf(1, d1);d1.insert(d1.begin()+2, 8845);d1.insert(d1.begin() + 5, 2, 321);dequeprintf(1, d1);d1.erase(d1.begin() + 5, d1.begin() + 7);d1.erase(d1.begin() + 2);dequeprintf(1, d1);/*d1.clear();dequeprintf(1, d1);*///at(int idx); //返回索引idx所指的数据//operator[]; //返回索引idx所指的数据//front(); //返回容器中第一个数据元素//back(); //返回容器中最后一个数据元素cout << endl << "deque 数据存取部分" << endl;for (int i = 0; i < d1.size(); i++){cout << d1.at(i) << " ";}cout << endl;for (int i = 0; i < d1.size(); i++){cout << d1[i] << " ";}cout << endl;cout << "d1容器中的第一个数据元素是：" << d1.front() << endl;cout << "d1容器中的最后一个数据元素是：" << d1.back() << endl;//利用算法实现对deque容器进行排序//sort(iterator beg, iterator end) //对beg和end区间内元素进行排序//总结：sort算法非常实用，使用时包含头文件 algorithm即可cout << endl << "deque 排序部分" << endl;sort(d1.begin(), d1.end());cout << "d1进行sort()排序之后的结果是：";dequeprintf(1, d1);
}

3.4、栈和队列（stack && queue）

3.4.1、栈（stack）

概念：stack是一种先进后出(First In Last Out,FILO)的数据结构，它只有一个出口

栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为

栈中进入数据称为 — 入栈 push
栈中弹出数据称为 — 出栈 pop

功能描述：栈容器常用的对外接口
构造函数：

stack stk; //stack采用模板类实现， stack对象的默认构造形式
stack(const stack &stk); //拷贝构造函数

赋值操作：

stack& operator=(const stack &stk); //重载等号操作符

数据存取：

push(elem); //向栈顶添加元素
pop(); //从栈顶移除第一个元素
top(); //返回栈顶元素

大小操作：

empty(); //判断堆栈是否为空
size(); //返回栈的大小

3.4.2、队列（queue）

概念：Queue是一种先进先出(First In First Out,FIFO)的数据结构，它有两个出口

队列容器允许从一端新增元素，从另一端移除元素
队列中只有队头和队尾才可以被外界使用，因此队列不允许有遍历行为

队列中进数据称为 — 入队 push
队列中出数据称为 — 出队 pop

功能描述：栈容器常用的对外接口
构造函数：

queue que; //queue采用模板类实现，queue对象的默认构造形式
queue(const queue &que); //拷贝构造函数

赋值操作：

queue& operator=(const queue &que); //重载等号操作符

数据存取：

push(elem); //往队尾添加元素
pop(); //从队头移除第一个元素
back(); //返回最后一个元素
front(); //返回第一个元素

大小操作：

empty(); //判断堆栈是否为空
size(); //返回栈的大小

#include <iostream>
using namespace std;
#include <stack>
#include <queue>
class person11
{public:person11(string name, string task){this->name = name;this->task = task;}public:string name;string task;
};/*堆和栈*/
void stackandqueue(void)
{/*stack*//*赋值操作：stack& operator=(const stack &stk); //重载等号操作符数据存取：push(elem); //向栈顶添加元素pop(); //从栈顶移除第一个元素top(); //返回栈顶元素大小操作：empty(); //判断堆栈是否为空size(); //返回栈的大小*/stack<int> s;if (s.empty()){cout << "s-栈是空的，清插入数据" << endl;}//入栈--插入数据for (int i = 0; i < 10; i++){s.push(i * 10);}if (s.empty()){cout << "s-栈是空的，清插入数据" << endl;return;}elsecout << "堆栈的大小是：" << s.size() << endl;//出栈cout << "栈顶的元素是：";while (!s.empty()){cout << s.top() << " ";//返回栈顶的元素s.pop(); //移除栈顶的元素}cout << endl;cout << "栈的大小是：" << s.size() << endl;/*queue--队列*/queue<person11>q;//定义成员person11 p1("悟空", "保护唐曾");person11 p2("悟净", "挑担");person11 p3("悟能", "吃");person11 p4("唐曾", "献爱心");//添加到队列q.push(p1);q.push(p2);q.push(p3);q.push(p4);//打印cout << "队列大小是：" << q.size() << endl;while (!q.empty()){cout << "返回队列的首个元素的姓名：" << q.front().name << " 任务：" << q.front().task << endl;cout << "返回队列的最后一个元素的姓名：" << q.back().name << " 任务：" << q.back().task << endl;cout  << endl;q.pop();//移除首个元素}cout << "队列大小是：" << q.size() << endl;
}

3.5、list容器

功能：将数据进行链式存储

链表（list）是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的
链表的组成：链表由一系列结点组成
结点的组成：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域
STL中的链表是一个双向循环链表

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

list的优点：

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

链表灵活，但是空间(指针域) 和时间（遍历）额外耗费较大

List有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效，这在vector是不成立的。

总结：STL中List和vector是两个最常被使用的容器，各有优缺点

#include <iostream>
using namespace std;
#include <list>void listproject(void);void listprintf(list<int>& l)
{if (l.empty())//判断是否为空{cout << "该容器为空" << endl;return;}for (list<int>::iterator it = l.begin(); it != l.end(); it++){cout << *it << " ";}cout << endl;
}bool myCompare(int val1, int val2)
{return val1 > val2;
}void listtest(void)
{/*构造函数*///list<T> lst; //list采用采用模板类实现,对象的默认构造形式：//list(beg, end); //构造函数将[beg, end)区间中的元素拷贝给本身。//list(n, elem); //构造函数将n个elem拷贝给本身。//list(const list & lst); //拷贝构造函数。list <int> l1;//尾插for (int i = 0; i < 10; i++){l1.push_back(i*10);}//头插for (int i = 0; i < 10; i++){l1.push_front(i+10);}cout << "l1 = ";listprintf(l1);list<int>l2(l1.begin(),l1.end());cout << "l2 = ";listprintf(l2);list <int>l3(10, 999);cout << "l3 = ";listprintf(l3);list <int>l4(l3);cout << "l4 = ";listprintf(l4);/*赋值和交换*///assign(beg, end); //将[beg, end)区间中的数据拷贝赋值给本身。//assign(n, elem); //将n个elem拷贝赋值给本身。//list& operator=(const list & lst); //重载等号操作符//swap(lst); //将lst与本身的元素互换。list<int>l5;l5.assign(l1.begin(), l1.end());cout << "l5 = ";listprintf(l5);list<int>l6;l6.assign(10,88);cout << "l6 = ";listprintf(l6);list<int>l7;l7 = l6;cout << "l7 = ";listprintf(l7);cout << "l4与l6交换以后:" << endl;l6.swap(l4);cout << "l4 = ";listprintf(l4);cout << "l6 = ";listprintf(l6);/*容器大小*///size(); //返回容器中元素的个数//empty(); //判断容器是否为空//resize(num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。//resize(num, elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。cout << "l1的大小是：" << l1.size() << endl;l2.resize(10);cout << "重新指定l2的大小：= ";listprintf(l2);/*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值匹配的元素。list<int>::iterator it = l5.begin();it++;it++;l5.insert(it, 8888);cout << "l5 = ";listprintf(l5);l5.insert(++l5.begin(), 2, 77777);cout << "l5 = ";listprintf(l5);l5.erase(++l5.begin(), it);cout << "l5 = ";listprintf(l5);l5.clear();cout << "l5 = ";listprintf(l5);/*list 数据存取*///front(); //返回第一个元素。//back(); //返回最后一个元素。cout << "l1的第一个元素是：" << l1.front() << endl;cout << "l1的最后一个元素是：" << l1.back() << endl;/*list的反转和排序*///reverse(); //反转链表//sort(); //链表排序--默认从小到大cout << "l2反转之后的内容是：";l2.reverse();listprintf(l2);cout << "l1 = ";l1.sort();//从小到大listprintf(l1);cout << "l1 = ";l1.sort(myCompare);//从大到小listprintf(l1);listproject();}
class person12
{public:person12(string name, int age, int height){this->name = name;this->age = age;this->height = height;}
public:string name;int age;int height;};
bool campareperson12(person12& p1, person12& p2)
{if (p1.age == p2.age)return p1.height > p2.height;elsereturn p1.age < p2.age;
}
void listproject(void)
{int tempage = 0;int tempheight = 0;list<person12>p;person12 p1("悟空", 1825, 18000);person12 p2("悟净", 25, 25);person12 p3("悟能", 8741, 1589);person12 p4("唐曾", 25, 12);person12 p5("如来", 25, 188000);person12 p6("观音", 48595, 2895);person12 p7("二郎神", 1024, 7859);person12 p8("哮天犬", 25, 4564);person12 p9("雷震子", 763210, 7859);person12 p10("哪吒", 25, 74582);//添加进列表    p.push_back(p1);p.push_back(p2);p.push_back(p3);p.push_back(p4);p.push_back(p5);p.push_back(p6);p.push_back(p7);p.push_back(p8);p.push_back(p9);p.push_back(p10);for (list<person12>::iterator it = p.begin(); it != p.end(); it++){cout << "姓名：" << it->name << "\t年龄：" << it->age << "\t身高：" << it->height << endl;}cout << "-----------------------------------------------" << endl;p.sort(campareperson12);for (list<person12>::iterator it = p.begin(); it != p.end(); it++){cout << "姓名：" << it->name << "\t年龄：" << it->age << "\t身高：" << it->height << endl;}
}

3.6、set和multiset容器

#include <iostream>
using namespace std;
#include <set>void setprintf(set<int>& s)
{if (s.empty())//判断是否为空{cout << "该容器为空" << endl;return;}for (set<int>::iterator it = s.begin(); it != s.end(); it++){cout << *it << " ";}cout << endl;
}
//创建仿函数
class mycampare
{public:bool operator()(int v1, int v2)const{return v1 > v2;}
};
class person13
{public:person13(string name, int age, int height){this->name = name;this->age = age;this->height = height;}public:string name;int age;int height;
};
class mycampareperson13
{public:bool operator()(const person13 &p1, const person13 &p2)const{return p1.age > p2.age;}
};
//所有元素都会在插入时自动被排序
//set/multiset属于关联式容器，底层结构是用二叉树实现
//set和multiset区别：
//set不允许容器中有重复的元素
//multiset允许容器中有重复的元素
void setest(void)
{/*构造函数*///构造：//set<T> st; //默认构造函数：//set(const set & st); //拷贝构造函数//赋值：set& operator=(const set & st); //重载等号操作符set<int>s1;//插入11个数据，其中有两个89s1.insert(89);s1.insert(47);s1.insert(86);s1.insert(35);s1.insert(59);s1.insert(46);s1.insert(73);s1.insert(64);s1.insert(21);s1.insert(89);s1.insert(36);cout << "s1的大小是：" << s1.size() << endl;setprintf(s1);set<int>s2(s1);setprintf(s2);set<int>s3;s3 = s1;setprintf(s3);/*set容器插入数据时用insertset容器插入数据的数据会自动排序*//*set大小和交换*///统计set容器大小以及交换set容器//size(); //返回容器中元素的数目//empty(); //判断容器是否为空//swap(st); //交换两个集合容器s1.swap(s3);setprintf(s1);setprintf(s3);/* set插入和删除*///insert(elem); //在容器中插入元素。//clear(); //清除所有元素//erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器。//erase(beg, end); //删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。//erase(elem); //删除容器中值为elem的元素。s1.erase(++s1.begin());setprintf(s1);/*set查找和统计*///find(key); //查找key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();//count(key); //统计key的元素个数set<int>::iterator pos = s1.find(73);if (pos != s1.end()){cout << "数据查找成功：" << *pos << endl;}else{cout << "暂无该数据" << endl;}int num = s1.count(86); cout << "num = " << num << endl;//set不可以插入重复数据，而multiset可以//set插入数据的同时会返回插入结果，表示插入是否成功//multiset不会检测数据，因此可以插入重复数据s1.insert(89);pair<set<int>::iterator, bool> ret = s1.insert(89);if (ret.second){cout << "插入成功" << endl;}elsecout << "插入失败" << endl;multiset<int> m1;m1.insert(10);m1.insert(10);for (multiset<int>::iterator it = m1.begin(); it != m1.end(); it++){cout << *it << " ";}cout << endl;/*对组pair*//*两种方式*///第一种方式pair<string, int> p1("大锤", 52);cout << "姓名：" << p1.first << " 年龄：" << p1.second << endl;pair<string, int>p2 = make_pair("大猫", 20);cout << "姓名：" << p2.first << " 年龄：" << p2.second << endl;/*set排序*///默认升序//降序实现（使用仿函数）set<int, mycampare> s4;s4.insert(89);s4.insert(47);s4.insert(86);s4.insert(35);s4.insert(59);s4.insert(46);s4.insert(73);s4.insert(64);s4.insert(21);s4.insert(89);s4.insert(36);for (set<int, mycampare>::iterator it = s4.begin(); it != s4.end(); it++){cout << *it << " ";}cout << endl;//自定义数据类型--对于自定义数据类型，set必须指定排序规则才可以插入数据set<person13,mycampareperson13>s5;person13 p4("悟空", 1825, 18000);person13 p5("悟净", 25, 25);person13 p6("悟能", 8741, 1589);s5.insert(p4);s5.insert(p5);s5.insert(p6);for (set<person13, mycampareperson13>::iterator it = s5.begin(); it != s5.end(); it++){cout << "姓名：" << it->name << " 年龄：" << it->age << " 身高：" << it->height << endl;}cout << endl;
}

3.7、map/ multimap容器

map基本概念

简介：map中所有元素都是pair

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

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

优点：

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

map和multimap区别：

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

#include <iostream>
using namespace std;
#include <map>
#include <vector>
#include <time.h>void empgroup(void);void mapprintf(map<int, int>& m)
{if (m.empty()){cout << "该容器为空" << endl;return;}for (map<int, int>::iterator i = m.begin(); i != m.end(); i++){cout << i->second << " ";}cout << endl;
}class mapcampare
{public:bool operator()(int a, int b)const{return a > b;}
};void maptest(void)
{map<int, int>m1;m1.insert(pair<int, int>(1, 10));m1.insert(pair<int, int>(10, 80));m1.insert(pair<int, int>(2, 50));m1.insert(pair<int, int>(4, 20));m1.insert(pair<int, int>(3, 70));mapprintf(m1);/*size(); //返回容器中元素的数目empty(); //判断容器是否为空swap(st); //交换两个集合容器*/cout << "map容器的大小是：" << m1.size() << endl;map<int, int>m2;m2.insert(make_pair(24,678));m2.insert(make_pair(2,34));m2.insert(make_pair(45,670));m2.insert(make_pair(89,3456));m2.insert(make_pair(20,531));mapprintf(m2);/*m2.swap(m1);mapprintf(m1);mapprintf(m2);*/m2.erase(m2.begin());m2.erase(20); mapprintf(m2);map<int, int>::iterator pos = m2.find(89);if (pos != m2.end()){cout << "查找成功：" << "key = " << pos->first << "  value = " << pos->second << endl;}else{cout << "查找失败" << endl;}//map容器默认排序规则为 按照key值进行 从小到大排序，掌握如何改变排序规则map<int, int, mapcampare> m3;m3.insert(make_pair(1, 56));m3.insert(make_pair(2, 48));m3.insert(make_pair(3, 23));for (map<int, int, mapcampare>::iterator it = m3.begin(); it != m3.end(); it++){cout << it->second << " ";}cout << endl;empgroup();
}
class mapworker
{public:/*mapworker() {};mapworker(string name, int salary){this->name = name;this->salary = salary;}*/public:string name;int salary;
};void creatworkermassage(vector<mapworker>&v)
{string allname = "abcdefghij";for (int i = 0; i < 10; i++){mapworker worker;worker.name = "员工";worker.name += allname[i];worker.salary = rand() % 10000 + 10000;v.push_back(worker);}
}void insertworker(vector<mapworker>& v, multimap<int, mapworker>& m)
{for (vector<mapworker>::iterator i = v.begin(); i != v.end(); i++){int num = rand() % 3;cout << " " << num;m.insert(make_pair(num, *i));}cout << endl;
}void showmapmassage(multimap<int,mapworker>&m)
{int count = 0;multimap<int, mapworker>::iterator pos;cout << "市场部" << endl;pos = m.find(0);count = m.count(0);for (int i=0;pos!=m.end()&&i<count; i++, pos++){cout << "姓名：" << pos->second.name << " 工资：" << pos->second.salary << endl;}cout << "工程部" << endl;pos = m.find(1);count = m.count(1);for (int i = 0; pos != m.end() && i < count; i++, pos++){cout << "姓名：" << pos->second.name << " 工资：" << pos->second.salary << endl;}cout << "董事办" << endl;pos = m.find(2);count = m.count(2);for (int i = 0; pos != m.end() && i < count; i++, pos++){cout << "姓名：" << pos->second.name << " 工资：" << pos->second.salary << endl;}
}
void empgroup(void)
{/*srand((unsigned int)time(NULL));*/vector<mapworker> v;multimap<int, mapworker> m;creatworkermassage(v);insertworker(v, m);showmapmassage(m);
}

4、STL-函数对象

4.1、函数对象

函数对象概念

重载函数调用操作符的类，其对象常称为函数对象
函数对象使用重载的()时，行为类似函数调用，也叫仿函数

本质：

函数对象(仿函数)是一个类，不是一个函数

特点：

函数对象在使用时，可以像普通函数那样调用, 可以有参数，可以有返回值
函数对象超出普通函数的概念，函数对象可以有自己的状态
函数对象可以作为参数传递

#include <iostream>
using namespace std;/*
-函数对象在使用时，可以像普通函数那样调用, 可以有参数，可以有返回值
-函数对象超出普通函数的概念，函数对象可以有自己的状态
-函数对象可以作为参数传递
*/class myprintf
{public:myprintf(){count = 0;}int operator()(int a, int b){return a + b;}void operator()(string test){cout << test << endl;count++;}public:int count;
};void test03func(myprintf& mp, string ddd)
{mp(ddd);
}void func_obj(void)
{myprintf mp1;cout << mp1(3, 5) << endl;mp1("4656565");mp1("4df6565");mp1("4355465");mp1("46dfhfg");test03func(mp1, "65656");cout << "调用次数是：" << mp1.count << endl;
}

4.2、谓词

概念：

返回bool类型的仿函数称为谓词
如果operator()接受一个参数，那么叫做一元谓词
如果operator()接受两个参数，那么叫做二元谓词

#include <iostream>
using namespace std;#include <vector>
#include <algorithm>
#include <time.h>
/*
概念：
返回bool类型的仿函数称为谓词
如果operator()接受一个参数，那么叫做一元谓词
如果operator()接受两个参数，那么叫做二元谓词
*///创建谓词
class predicate
{public:bool operator()(int val)//一元谓词{return val > 5;}bool operator()(int v1, int v2)//二元谓词{return v1 > v2;}
};void predicateprintf(vector<int>& v)
{for (vector<int>::iterator i = v.begin(); i != v.end(); i++){cout << *i << " ";}cout << endl;
}void predicatetest(void)
{//srand((unsigned int)time(NULL));int score = 0;vector<int> v1;for (int i = 0; i < 15; i++){score = rand() % 20;v1.push_back(score);}//一元谓词vector<int>::iterator pos = find_if(v1.begin(),v1.end(), predicate());if (pos != v1.end()){cout << "找到大于5的数" << endl;}else{cout << "未找到" << endl;}cout << "排序前：";predicateprintf(v1);cout << "排序后：";sort(v1.begin(),v1.end());predicateprintf(v1);cout << "排序后：";sort(v1.begin(), v1.end(),predicate());predicateprintf(v1);
}

4.3、内建函数对象

概念：

STL内建了一些函数对象

分类:

算术仿函数
关系仿函数
逻辑仿函数

用法：

这些仿函数所产生的对象，用法和一般函数完全相同
使用内建函数对象，需要引入头文件 #include

#include <iostream>
using namespace std;#include <functional>
#include <algorithm>
#include <vector>void functionaltest(void)
{/*算数仿函数template<class T> T plus<T> //加法仿函数template<class T> T minus<T> //减法仿函数template<class T> T multiplies<T> //乘法仿函数template<class T> T divides<T> //除法仿函数template<class T> T modulus<T> //取模仿函数template<class T> T negate<T> //取反仿函数*/negate<int>n;cout << "取反仿函数（negate）:" << n(80) << endl;plus<int>p;cout << "加法仿函数（plus）:" << p(80, 20) << endl;minus<int>mi;cout << "减法仿函数（minus）:" << mi(80, 20) << endl;multiplies<int>mu;cout << "乘法仿函数（multiplies）:" << mu(80, 20) << endl;divides<int>d;cout << "除法仿函数（divides）:" << d(80, 35) << endl;modulus<int>mo;cout << "取模仿函数（余数modulus）:" << mo(80, 30) << endl;/*关系仿函数template<class T> bool equal_to<T> //等于template<class T> bool not_equal_to<T> //不等于template<class T> bool greater<T> //大于template<class T> bool greater_equal<T> //大于等于template<class T> bool less<T> //小于template<class T> bool less_equal<T> //小于等于*/vector<int>v1;int num;for (int i = 0; i < 10; i++){num = rand() % 50;v1.push_back(num);}cout << "排序前";for (vector<int>::iterator i = v1.begin(); i != v1.end(); i++){cout << *i << " ";}cout << endl;sort(v1.begin(), v1.end(), greater<int>());cout << "排序后";for (vector<int>::iterator i = v1.begin(); i != v1.end(); i++){cout << *i << " ";}cout << endl;/*逻辑仿函数template<class T> bool logical_and<T> //逻辑与template<class T> bool logical_or<T> //逻辑或template<class T> bool logical_not<T> //逻辑非*/vector<bool>v2;v2.push_back(true);v2.push_back(false);v2.push_back(true);v2.push_back(false);for (vector<bool>::iterator i = v2.begin(); i != v2.end(); i++){cout << *i << " ";}cout << endl;//逻辑非//需要包含 算法和内建（algorithm和functional） 头文件vector<bool>v3;v3.resize(v2.size());transform(v2.begin(), v2.end(), v3.begin(), logical_not<bool>());for (vector<bool>::iterator i = v3.begin(); i != v3.end(); i++){cout << *i << " ";}cout << endl;
}

5、STL-常用算法

后续在写，忙不过来了

C++学习记录---2相关推荐

Pytorch学习记录-torchtext和Pytorch的实例（使用神经网络训练Seq2Seq代码）
Pytorch学习记录-torchtext和Pytorch的实例1 0. PyTorch Seq2Seq项目介绍 1. 使用神经网络训练Seq2Seq 1.1 简介,对论文中公式的解读 1.2 数据预 ...
HTML5与CSS3权威指南之CSS3学习记录
title: HTML5与CSS3权威指南之CSS3学习记录 toc: true date: 2018-10-14 00:06:09 学习资料--<HTML5与CSS3权威指南>(第3版) ...
springboot @cacheable不起作用_Springboot学习记录13 使用缓存：整合redis
本学习记录的代码,部分参考自gitee码云的如下工程.这个工程有详尽的Spingboot1.x教程.鸣谢! https://gitee.com/didispace/SpringBoot-Learnin ...
【Cmake】Cmake学习记录
Cmake学习记录 1.1 常例 add_library(gen_reference_infogen_reference_info/gen_reference_info.hgen_reference_ ...
ASP.NETCore学习记录(一)
ASP.NETCore学习记录(一) asp.net core介绍 Startup.cs ConfigureServices Configure 0. ASP.NETCore 介绍 ASP.N ...
Android开发技术周报176学习记录
Android开发技术周报176学习记录教程当 OkHttp 遇上 Http 2.0 http://fucknmb.com/2018/04/16/%E5%BD%93OkHttp%E9%81%87% ...
add函数 pytorch_Pytorch学习记录-Pytorch可视化使用tensorboardX
Pytorch学习记录-Pytorch可视化使用tensorboardX 在很早很早以前(至少一个半月),我做过几节关于tensorboard的学习记录. https://www.jianshu.co ...
java之字符串学习记录
java之字符串学习记录 public class StringDemo { public static void main(String[] args) { //静态初始化字符串 String s1 ...
Redis的学习记录
Redis的学习记录 1.先导了解 1.1 NOSQL概述 1.1.1 为什么要用NoSql? 1.1.2 NoSql了解 1.1.3 NoSql特点 1.1.4 NoSQL的四大分类 2. Redi ...
Django学习记录-1
2019独角兽企业重金招聘Python工程师标准>>> 作为Django的初学者,记录下我的学习历程,加深一下记忆(工作中用java,所以很容易忘记),如果有写的不对的地方,还望大家 ...

C++学习记录---2

1、模板

1.1、函数模板

1.2、类模板

1.2.1、类模板基本应用

1.2.2、类模板与函数模板区别

1.2.3、类模板中成员函数创建时机

1.2.4、类模板对象做函数参数

1.2.5、类模板与继承

1.2.6、类外声明类模板的成员函数

1.2.7、类模板与友元

2、STL初识

2.1、基本概念

2.2、vector容器嵌套容器

3、STL-常用容器

3.1、string容器

3.1.1、string赋值操作

3.1.2、string字符串拼接

3.1.3、string字符串查找和替换

3.1.4、string字符串比较

3.1.5、string存取

3.1.6、string插入和删除

3.1.7、string子串

3.2、vector容器

3.2.1、 vector构造函数

3.3、deque容器

3.4、栈和队列（stack && queue）

3.4.1、栈（stack）

3.4.2、队列（queue）

3.5、list容器

3.6、set和multiset容器

3.7、map/ multimap容器

4、STL-函数对象

4.1、函数对象

4.2、谓词

4.3、内建函数对象

5、STL-常用算法

C++学习记录---2相关推荐

最新文章

热门文章