目录
🎄前言
本篇博客主要介绍有关STL的知识，设计常用容器及常用算法等知识，内容细节会比较多，也比较细，希望对大家有所帮助。(●'◡'●)
文章会不定时更新细节，欢迎继续关注。
🎄概念
引入
复用性，这个是软件界希望达到的一个性能。
而复用性必须建立在某种标准下，
为了建立数据结构和算法的一套标准，而且降低他们的相互胶着的性质，而提升他们的独立性、弹性、交互操作性、因此在这个环境下，STL诞生了。
STL几乎所有代码都是用模板类和模板函数，提高了代码的重用性。
c++标准程序库中隶属于STL的已经超过百分之八十以上。
定义
STL（Standard Template Library）——每个字母分别代表标准、模板、库
STL不是面向对象的编程——而是一种不同的编程模式——通用编程技术
优点
不需要额外安装
高可重用性，高移植性，跨平台性
将数据和操作分离，数据由容器类别加以管理，
程序员不需要直到它的据体实现过程，只需要可以熟练使用即可
🎄六大组件
STL提供了六大组件，彼此之间可以组合套用。
容器、算法、迭代器、仿函数、适配器、空间配置器
容器
各种数据结构，用来存放数据，实现角度来看，STL容器实际上是一种类模板
算法
各种各样的算法，功能模板
迭代器
容器和算法的胶着剂，分为五种类型
每个容器都有自己的迭代器，初学阶段可以把它看为指针
仿函数
行为类似函数，可作为算法的某种策略，从实现角度来看，仿函数是一种重载了operator()的class或者是类模板
适配器
修饰容器或是仿函数或迭代器接口的东西
空间配置器
负责空间的配置和管理，
而其中的前三个组件是STL广义上的分类，主要重点就集中在这三个上
🎄三大组件
三大组件的关系——容器和算法通过迭代器来进行无缝连接，算法通过迭代器访问容器中的元素
实际上，所谓容器是存储数据的地方，而算法是操作，操作需要对数据进行，这时候需要迭代器来使这两个联系起来
迭代器（iterator）
定义
迭代器可以指向容器中的某个元素，通过迭代器可以指向容器中的元素，通过迭代器可以读写它指向的元素——因此它在某方面很像指针，初学者可以先把它看成指针使用
它是一种广义指针，它是一个可以完成类似指针操作的对象
迭代器是一个接口，指向容器的数据，然后算法通过这个迭代器去实现对容器的操作，相当于一个容器和算法的粘合剂
不同的容器通常有着自己的迭代器，迭代器的类型是一个iterator的typedef类型，作用域为整个类。
分类：
正向迭代器：
容器类名：：iterator 迭代器名
常量正向迭代器：
容器类名：：const_iterator 迭代器名
反向迭代器：
容器类名：：reverse_iterator 迭代器名
常量反向迭代器：
容器类名：：const_reverse_iterator 迭代器名
用法：
前面已经说过，它指向某个元素，可以看为指针，那*迭代器名就可以表示迭代器所指的元素了。
而每一个容器都有它自己的迭代器，根据不同迭代器指向的位置的不同，可以进行不同的用途，具体用法在下面容器中介绍——
🎄STL常用容器
介绍：
任何数据结构都是为了实现某种特定算法，STL容器就是将运用最广泛的一些数据结构实现出来，
例如——数组、链表、树、栈、队列、集合、映射表
他们可以根据在容器种的排列特性来分类——
分类
序列式——需要注意数据存储时的数据顺序
每个元素均有固定的位置，除非用删除或是插入改变这个位置，Vector容器，Deque容器，List容器等
关联式——不需要关心其顺序
非线性的树结构，二叉树结构，特点是——在值中选择一个树作为关键字key，起索引作用，Set和Map容器
作用
常用容器：
Vector容器
介绍：
- vector是将元素置于一个动态数组中加以管理的容器，可以随时添加数值和删除元素，存放内置数据类型
- vector可以随机存取元素
- vector尾部添加或移除元素非常快速。但是在中部或头部插入元素或移除元素比较费时
⭐注意：在局部区域中创建vector数组，在堆空间里开——因为栈区比较小，假如放非常长的数组会发生爆栈，因此局部区域不可以开大长度数组，但是可以开大长度vector
包含头文件——#include<vector>
⭐与数组的区别：vector可动态分配
动态分配——vector先开辟一块空间，然后假如需要的空间大于这个开辟的空间了，vector不会在原有空间后面再开辟一块空间，而是在其他地方再找一块空间，然后把原有空间的值给复制到这个新空间，然后插入需要的值，这种方法导致——原有的迭代器将没用了，它们指向的不是这个新的空间，而老的空间已经报废了，因此这个动态内存分配会出现这个问题
vector的迭代器是随机访问的迭代器
构造/初始化
vector容器采用模板构造
//1.默认构造
vector<类型> 数据名
//示例：
vector<node> a;//定义了一个叫a一维数组，而且数组存储结构体类型数据
//2.带参数的构造
vector<类型> 数据名（n）//n代表这个数组长度为n
vector<类型> 数据名(beg,end)//把beg到end区间里的所有元素赋值给这个，其中区间是左闭右开
//示例：
vector<int> b(n);//定义一个长度为n的数组，初始的默认值都为0，下标从0到n-1
//如果想指定初始化值
vector<int> b(n,1)//初始的默认值都为1了
//3.初始化多个元素
vector<类型> 数据名{数据}//定义一个数组，里面有的数据由定义时的{}里的数据决定
//4.拷贝初始化
vector<int> a(5,0)//定义一个数组，长度为5，初始值都为0
vector<int> b(a);//把a的所有数据都拷贝到b上，前提是所对应的b数组中的类型相同
vector<int> c=a;//c和a一样了
//5.二维构造
vector<int> a[10];//这里是定义一个第一维的长度为10且固定，而第二维可变化的二维数组
vector<vector<int>> b;//第一维第二维均可变
vector<vector<int>> c(n,vector<int>(m,0))//均固定，且初始值都为0
这里一般的都好理解，有一点难度的是嵌套构造——
vector<vector<int>> a
这个是一种嵌套构造方式，其中a它的每一个元素都是整型动态数组。
vector容器嵌套可以使用下标方式访问——前提是必须初始化一维数组的数量
vector<vector<int>>a(3,vector<int>(4,'\0'))拷贝构造函数，区间拷贝构造函数
自定义：vector<vector<int>>(行数，vector<int>()）
常用迭代器和遍历方法
数组名称.begin()
返回首元素的迭代器——地址
数组名称.end()
返回最后一个元素的后一个位置的迭代器——地址
数组名称.empty()
判断是否为空，空则返回真，反之返回假
数组名称.push_back()
在尾部插入值
数组名称.pop_back()
删除最后一个值
数组名称.clear()
数组名称.resize()
重新指定大小
数组名称.size()
返回数组的大小
数组名称.erase()
清除数组中的一些元素
补充：STL函数——排序
sort(beg,end).对区间beg到end里的数据从小到大排序
使用反向迭代器降序排序
遍历方法：
1.for循环来遍历
先使用函数，引用传参，在函数里放一个for循环，设置一个迭代器指向数组的开始，让这个迭代器不等于数组的最后，且每次执行都要加一次1.
代码如下：
void bl(vector<int>& a) { for (vector<int>::iterator it = a.begin(); it != a.end(); it++) { cout << *it << endl; } }
2.遍历算法——算法头文件#include<algorithms>
for_each(v.begin(),v.end(),myprint)
代码示例：
void fun(int i) { cout << i<<" "; } vector<int> b; b.assign(3,10); bl(b); for_each(b.begin(), b.end(), fun);
3.利用迭代器
//利用迭代器来遍历
vector<int>::iterator be = a.begin();
vector<int>::iterator en = a.end();
while (be != en)
{
cout << *be << " ";
be++;
}cout << endl;特殊遍历案例：
1.自定义数据类型遍历
2.嵌套式的容器遍历
赋值
vector.assign(beg,end);//将(beg,end)区间中的数据拷贝赋值给本身。注意该区间。
vector.assign(n,elem);//将n个elem拷贝赋值给本身。
vector&operator=(const vector &vec);//重载等号操作符
vector.swap(vec);/将vec与本身的元素互换。
使用示例：
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
//vector.assign(beg,end);//将(beg,end)区间中的数据拷贝赋值给本身。注意该区问。
//vector.assign(n, elem);//将n个elem拷贝赋值给本身。
//vector& operator=(const vector& vec);//重载等号操作符
//vector.swap(vec); / 将vec与本身的元素互换。
void bl(vector<int>& a)
{
for (vector<int>::iterator it = a.begin(); it != a.end(); it++)
{
cout << *it<<" ";
}
cout << endl;
}
void fun(int i)
{
cout << i<<" ";
}
void test1()
{
int s[5] = { 1,2,3,4,5 };
vector<int> a;
a.assign(s,s+4);
cout << "第一次赋值得出的值为" << endl;
bl(a);
a.assign(2, 10);
cout << "第二次赋值得出的值为" << endl;
bl(a);
vector<int> b;
b = a;
bl(b);
for_each(b.begin(), b.end(), fun);
cout << endl;
vector<int> c;
c.assign(4, 2);
//交换前的值
cout << "交换前的值" << endl;
bl(a);
bl(c);
a.swap(c);
//交换后的值
cout << "交换后的值" << endl;
bl(a);
bl(c);
}
int main() {
test1();
return 0;
}
大小、容量
resize(）//对容器的大小，进行修改，重新指定大小，如果重新指定的比原来长，默认用0填充新的位置，如果重新指定的比原来短，超出部分会删除掉
size()//判断容器大小
capcity()//判断容器容量
empty()//判断容器内是否为空
代码示例：
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
//resize(）//对容器的大小，进行修改，重新指定大小，如果重新指定的比原来长，默认用0填充新的位置，如果重新指定的比原来短，超出部分会删除掉
//size()//判断容器大小
//capcity()//判断容器容量
//empty()//判断容器内是否为空
void fun(int i)
{
cout << i<<" ";
}
void test1()
{
vector<int> a;
a.assign(5, 3);
for_each(a.begin(), a.end(),fun);
cout << endl;
if (empty(a))
{
cout << "容器为空" << endl;
}
else {
cout << "容器不为空" << endl;
cout << "容器大小为" << a.size() << endl;
cout << "容器容量为" << a.capacity() << endl;
}
a.resize(8);
cout << "重新制定大小大了" << endl;
for_each(a.begin(), a.end(), fun);
cout << endl;
a.resize(2);
cout << "重新制定大小小了" << endl;
for_each(a.begin(), a.end(), fun);
cout << endl;
}
int main() {
test1();
return 0;
}
插入删除操作
push_back(ele); //尾部插入元素ele
pop_back(); //删除最后一个元素
insert(const_iterator pos,ele); //迭代器指向位置pos插入元素ele
insert(const iterator pos,int count,ele);//迭代器指向位置pos插入count个元素ele
erase(const_iterator pos); //删除迭代器指向的元素
erase(const_iterator start, const.iterator end);//删除迭代器从start到end之间的元素
clear(); //删除容器中所有元素
代码示例：
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
//push_back(ele); //尾部插入元素ele
//pop_back(); //删除最后一个元素
//insert(const_iterator pos, ele); //迭代器指向位置pos插入元素ele
//insert(const iterator pos, int count, ele);//迭代器指向位置pos插入count个元素ele
//erase(const_iterator pos); //删除迭代器指向的元素
//erase(const_iterator start, const.iterator end);//删除迭代器从start到end之间的元素
//clear(); //删除容器中所有元素
void fun(int i)
{
cout << i<<" ";
}
void test1()
{
vector<int> a;
a.push_back(1);
a.push_back(2);
a.push_back(3);
a.push_back(4);
a.push_back(5);
//12345，不删除元素的情况下的原始数据
cout << "不删除元素的情况下的原始数据" << endl;
for_each(a.begin(), a.end(), fun);
cout << endl;
//删除了最后一个元素的数据
cout << "删除了最后一个元素的数据" << endl;
a.pop_back();
for_each(a.begin(), a.end(), fun);
cout << endl;
//插入了一个0后的数据
cout << "插入了一个0后的数据" << endl;
a.insert(a.begin(), 0);
for_each(a.begin(), a.end(), fun);
cout << endl;
//又插入了两个0后的数据
cout << "又插入了两个0后的数据" << endl;
a.insert(a.begin(), 2,0);
for_each(a.begin(), a.end(), fun);
cout << endl;
//删除了开始迭代器指向的位置
cout << "删除了开始迭代器指向的位置" << endl;
a.erase(a.begin());
for_each(a.begin(), a.end(), fun);
cout << endl;
//删除了开始迭代器到迭代器往后的两位之间的数据
cout << "删除了开始迭代器到迭代器往后的两位之间的数据" << endl;
a.erase(a.begin(), a.begin() + 2);
for_each(a.begin(), a.end(), fun);
cout << endl;
}
int main() {
test1();
return 0;
}
元素访问和存取方式
at(iht idx); //返回索引idx所指的数据
operator[ ]; //返回索引idx所指的数据
front(); //返回容器中第一个数据元素
back(); //返回容器中最后一个数据元素
代码示例：
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
//at(iht idx); //返回索引idx所指的数据
//operator[ ]; //返回索引idx所指的数据
//front(); //返回容器中第一个数据元素
//back(); //返回容器中最后一个数据元素
void fun(int i)
{
cout << i<<" ";
}
void test1()
{
vector<int> a;
a.push_back(1);
a.push_back(2);
a.push_back(3);
a.push_back(4);
a.push_back(5);
cout << "a的第三个数据" << a.at(2) << endl;
cout << "a的第三个数据" << a[2] << endl;
cout << "a的第一个数据元素" << a.front() << endl;
cout << "a的最后一个数据元素" << a.back() << endl;
}
int main() {
test1();
return 0;
} 
vector容器互换操作的扩展使用
前面已经知道了交换是用swap函数来完成的，而这个swap函数不止可以交换两个容器的数据，还可以进行收缩内存——
这里先看一段代码：
#include<iostream> #include<vector> #include<algorithm> using namespace std; //swap收缩内存 void fun(int i) { cout << i<<" "; } void test1() { vector<int> a; a.push_back(1); a.push_back(2); a.push_back(3); a.push_back(4); a.push_back(5); //重新指定内存后的大小和容量 cout << "重新指定内存后的大小和容量" << endl; a.resize(100); cout << a.size() << endl; cout << a.capacity() << endl; //又重新指定小的内存后的大小和容量 cout << "又重新指定小的内存后的大小和容量" << endl; a.resize(3); cout << a.size() << endl; cout << a.capacity() << endl; } int main() { test1(); return 0; }
、
指定两次内存后，容器的大小倒是变了，但是容量没变，这会造成很大的浪费，很不好，所以怎么才能把容量也缩小呢？——往下看吧🤭
先看这里代码怎么写的，然后再讲为何这样写：
//利用swap收缩容量后
cout << "利用swap收缩容量后" << endl;
vector<int>(a).swap(a);
cout << a.size() << endl;
cout << a.capacity() << endl; 
这时候就实现了一个收缩内存的效果，但为什么要这样写？为什么这样写可以达到这个效果呢？
且听下面讲解——
1.首先这个vector<int>(a)是个匿名对象，它有一个特征就是——匿名对象执行完后编译器会回收空间，所在的空间被释放
如下图详解：
vector容器的预留问题
reserve预留空间
因为vector的特殊性质——它动态开辟内存，如果空间不够，它要在另一块区域开辟足够内存，然后把之前的空间里的数给复制过来，这样导致之前的迭代器都不能用了，因此这里提供一个功能可以提前去开辟足够的空间——👇
string容器
补充概念
const char*
这个是代表指针指向的东西不可以通过指针来修改了,但是指针本身的地址可以改变，但可以间接不通过指针来修改指向的内容
char const*
等价于const char*
char*const
指针指向的东西定了，不可以指向其他了，表明指针的指向不可改变
const char
c语言中常用的字符数据类型
⭐注：指针改为引用——用法一样
概念
~string容器其实和c语言中的char很像，而string是c++风格的字符串，而string本质上是一个类
特点
string是一个类，类内部封装了char*,管理这个字符串，是一个char*型的容器
string类内部封装了很多成员方法
string管理char*所分配的内存
构造
string(); //创建一个空的字符串例如：string str;
string(const char*s); //使用字符串s初始化
string(const string& str); //使用一个string对象初始化另一个string对象
string(int n, char c); //使用n个字符c初始化代码示例：
#include<iostream> #include<string> #include<algorithm> using namespace std; //string(); //创建一个空的字符串例如：string str; //string(const char* s); //使用字符串s初始化 //string(const string& str); //使用一个string对象初始化另一个string对象 //string(int n, char c); //使用n个字符c初始化 void test1() { string a="hehe"; string b(a); string c("哈哈"); string d(3, 'a'); cout << a << endl; cout << b << endl; cout << c << endl; cout << d << endl; } int main() { test1(); return 0; }
赋值
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个字符e赋给当前字符串代码示例：
#include<iostream> #include<string> #include<algorithm> 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个字符e赋给当前字符串 void test1() { string a="heha"; string b=a; cout << a << endl;//heha cout << b << endl;//heha string c; const char* s = "黑菜钟"; c.assign(s); cout << c << endl;//黑菜钟 c.assign(a,2); cout << c << endl;//he c.assign(b); cout << c << endl;//heha c.assign(3, 'h'); cout << c << endl;//hhh } int main() { test1(); return 0; }
这个需要注意有的是传入const char*类型的，有的是传入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> #include<string> #include<algorithm> 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 test1() { string a="我"; string b = "辣条"; a += ("吃"); a += (b); a += ("a"); cout << a << endl; string c = "abc"; string d = "k"; c.append("de"); c.append("fghee", 3); c.append(d); cout << c << endl; } int main() { test1(); return 0; }
查找和替换
int find(const string& str, int pos) const; //查找str第一次出现位置，从pos开始查找
int find(const char* s, int pos )const; //查找s第一次出现位置，从pos开始查找
int find(const char* s, int pos, int n) const; //从pos位置查找s的前个字符第一次位置
int find(const char c, int pos) const; //查找字符c第一次出现位置
int rfind(const string& str, int pos) const; //查找str最后一次位置，从pos开始查找
int rfind(const char* s, int pos) const; //查找s最后一次出现位置，从pos开始查找
int rfind(const char* s, int pos, int n) const; //从pos查找s的前n个字符最后一次位置
int rfind(const char c, int pos) 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
注意：⭐rfind从右往左查找 find从左往右查找
代码案例：
#include<iostream> #include<string> using namespace std; //int find(const string& str, int pos) const; //查找str第一次出现位置，从pos开始查找 //int find(const char* s, int pos )const; //查找s第一次出现位置，从pos开始查找 //int find(const char* s, int pos, int n) const; //从pos位置查找s的前个字符第一次位置 //int find(const char c, int pos) const; //查找字符c第一次出现位置 //int rfind(const string& str, int pos) const; //查找str最后一次位置，从pos开始查找 //int rfind(const char* s, int pos) const; //查找s最后一次出现位置，从pos开始查找 //int rfind(const char* s, int pos, int n) const; //从pos查找s的前n个字符最后一次位置 //int rfind(const char c, int pos) 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 test1() { string a = "abcdefgde"; int pos = a.find("de", 0);//3 cout << pos << endl; pos = a.find("cf");//-1=>未找到 cout << pos << endl; pos = a.rfind("de");//7 cout << pos << endl; //替换 string b = "abcdefg"; b.replace(1, 3, "1234");//a1234efg cout << b << endl; } int main() { test1(); return 0; }
字符串比较
字符串比较是按字符的ASCII码进行对比
=则返回0
>则返回1
<则返回-1
函数原型——
int compare(const string &s) const; //与字符串s比较
int compare(const char *s) const; //与字符串s比较
代码案例：
#include<iostream>
#include<string>
using namespace std;
//int compare(const string& s) const; //与字符串s比较
//int compare(const char* s) const; //与字符串s比较
void test1()
{
string a = "abc";
string b = "a";
int f = a.compare(b);
cout << f << endl;//1
f = a.compare("abcd");
cout << f << endl;//-1
f = a.compare("abc");//0
cout << f << endl;
}
int main() {
test1();
return 0;
}
存取
存取方式有两种：
1.char& operator[](int n);
2.char &at(int a);
代码示例：
#include<iostream>
#include<string>
using namespace std;
//存取
// 1.char& operator[](int n);
//2.char& at(int a);
void test1()
{
string a = "abcd";
cout << a.at(0) << endl;//a
cout << a[2]<<endl;//c
}
int main() {
test1();
return 0;
}
插入删除
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 npos); //删除从pos开始的n个字符代码案例：
#include<iostream> #include<string> using namespace std; //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 npos); //删除从pos开始的n个字符 void test1() { string a = "abcd"; string b = "gef"; a.insert(2, "111"); cout << a << endl; a.insert(7, b); cout << a << endl; a.insert(10, 2, 'a'); cout << a << endl; a.erase(2, 4); cout << a << endl; string c = a.substr(0, 6); cout << c << endl; } int main() { test1(); return 0; }
子串
从字符串中获取想要的子串
函数原型：
string substr(int pos o,int npos) const; //返回由pos开始的n个字符组成的字符串代码案例：
#include<iostream> #include<string> using namespace std; //子串 void test1() { string a = "abcdef"; string c = a.substr(0,4); cout << c << endl; } int main() { test1(); return 0; }
deque容器
概念：
区别——vector为单端数组，头插不好插，而这个头插比较方便，vector的访问遍历比较快，因为它是连续的空间
deque与vector区别：
vector对于头部的插入删除效率低，数据量越大，效率越低
deque相对而言，对头部的插入删除速度回比vector快
vector访问元素时的速度会比deque快，这和两者内部实现有关
工作原理：
赋值
deque&operator=(const deque &a); //重载等号=操作符
assign(beg,end); //将【beg,end】区间中的数据拷贝赋值给本身，注意这个不可以是数组，要是迭代器
assign(n,elem); //将n个elem拷贝赋值给本身代码示例：
#include<iostream> #include<deque> using namespace std; //deque&operator=(const deque &a); //重载等号=操作符 //assign(beg, end); //将【beg,end】区间中的数据拷贝赋值给本身,注意这个不可以是数组，要是迭代器 //assign(n, elem); //将n个elem拷贝赋值给本身 void print(deque<int>& a) { for (deque<int>::iterator it = a.begin(); it != a.end(); it++) { cout << *it; }cout << endl; } void test1() { deque <int>a; deque <int>b; deque<int>c; c.push_back(1); c.push_back(2); c.push_back(3); c.push_back(4); c.push_back(5); a.assign(3, 8); print(a); a.assign(c.begin(), c.end()); print(a); b = a; print(b); } int main() { test1(); return 0; }
大小
deque.empty(); //判断容器是否为空
deque.size(); //返回容器中元素的个数
deque.resize(num); //重新指定容器的长度为num,若容器变长，则以默认值填充新位置。
//如果容器变短，则末尾超出容器长度的元素被删除。
deque.resize(num,elem); //重新指定容器的长度为num,若容器变长，则以elem值填充新位置。
//如果容器变短，则末尾超出容器长度的元素被删除。代码示例：
#include<iostream> #include<deque> using namespace std; //deque.empty(); //判断容器是否为空 //deque.size(); //返回容器中元素的个数 //deque.resize(num); //重新指定容器的长度为num,若容器变长，则以默认值填充新位置。 如果容器变短，则末尾超出容器长度的元素被删除。 //deque.resize(num, elem); //重新指定容器的长度为num,若容器变长，则以elem值填充新位置。 如果容器变短，则末尾超出容器长度的元素被删除。 void print(const deque<int>& a) { for (deque<int>::const_iterator it = a.begin(); it != a.end(); it++) { cout << *it; }cout << endl; } void test1() { deque <int>a; a.push_back(1); a.push_back(2); a.push_back(3); a.push_back(4); a.push_back(5); if (a.empty()) { cout << "为空" << endl; }else { cout << a.size() << endl; } a.resize(3); print(a); a.resize(8); print(a); } int main() { test1(); return 0; }
插入和删除操作
两端插入操作：
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)区间的数据，v无返回值。
clear(); //清空容器的所有数据
erase(beg,end); //删除【beg,end)区间的数据，返回下一个数据的位置。
erase(pos); /删除pos位置的数据，返回下一个数据的位置。代码示例：
#include<iostream> #include<deque> using namespace std; //两端插入操作： //push back(elem); //在容器尾部添加一个数据 //push_front(elem); //在容器头部插入一个数据 //pop_back(); //删除容器最后一个数据 //pop_front(); //删除容器第一个数据 //指定位置操作： //insert(pos, elem); //在pos位置插入一个elem元素的拷贝，返回新数据的位置。注意pos位置为迭代器 //insert(pos, n, elem); //在pos位置插入n个elem数据，无返回值。 //insert(pos, beg, end); //在pos位置插入【beg,end)区间的数据，无返回值。 //clear(); //清空容器的所有数据 //erase(beg, end); //删除【beg,end)区间的数据，返回下一个数据的位置。 //erase(pos); / 删除pos位置的数据，返回下一个数据的位置。 void print(const deque<int>& a) { for (deque<int>::const_iterator it = a.begin(); it != a.end(); it++) { cout << *it; }cout << endl; } void test1() { deque <int>a; int i = 1; for (; i < 6; i++) { a.push_back(i); } print(a); a.push_front(0); print(a); a.pop_back(); print(a); a.pop_front(); print(a); deque<int> b; b.assign(3, 4); b.insert(b.begin(), 2); print(b); b.insert(b.begin(), 2,0); print(b); b.insert(b.end(), a.begin(), a.end()); print(b); b.clear(); print(b); a.erase(a.begin()); print(a); } int main() { test1(); return 0; }
查找存取
at(int idx); //返回索引idx所指的数据
operator[]; /返回索引idx所指的数据
front(); //返回容器中第一个数据元素
back(); //返回容器中最后一个数据元素代码示例：
#include<iostream> #include<deque> using namespace std; //at(int idx); //返回索引idx所指的数据 //operator[]; / 返回索引idx所指的数据 //front(); //返回容器中第一个数据元素 //back(); //返回容器中最后一个数据元素 void print(const deque<int>& a) { for (deque<int>::const_iterator it = a.begin(); it != a.end(); it++) { cout << *it; }cout << endl; } void test1() { deque <int>a; int i = 1; for (; i < 6; i++) { a.push_back(i); } cout << a.at(0) << endl; cout << a[0] << endl; cout << a.front() << endl; cout << a.back() << endl; } int main() { test1(); return 0; }
排序
利用算法实现对deque容器进行排序——标准算法头文件，algorithm
sort(iterator beg,iterator end) //对beg和end区间内元素进行排序这个排序为升序排列，但是也可以通过一些操作完成降序排列，后面再讲
代码示例：
#include<iostream> #include<deque> #include<algorithm> using namespace std; //利用算法实现对deque容器进行排序——标准算法头文件，algorithm //sort(iterator beg, iterator end) //对beg和end区间内元素进行排序 // //这个排序为升序排列，但是也可以通过一些操作完成降序排列，后面再讲 void print(const deque<int>& a) { for (deque<int>::const_iterator it = a.begin(); it != a.end(); it++) { cout << *it; }cout << endl; } void test1() { deque <int>a; a.push_back(4); a.push_back(3); a.push_back(6); a.push_back(1); a.push_back(2); a.push_back(5); sort(a.begin(), a.end()); print(a); } int main() { test1(); return 0; }
stack容器
stack是一种先进后出的数据结构，只有一个出口，也就是我们俗说的栈
栈不允许有遍历行为，只有顶部元素可以使用
构造
构造函数：
stack<t> stk;采用模板类实现，stack对象的默认构造形式
stack(const stack &stk);//拷贝构造函数
赋值
赋值操作：
stack&operator=(const stack &stk); //重载等号操作符
存取
数据存取：
push(elem); //向栈顶添加元素
基本接口
pop(); //从栈顶移除第一个元素
top(); //返回栈顶元素
大小
大小操作：
empty(); //判断堆栈是否为空
size(); //返回栈的大小
代码示例：
#include<iostream>
#include<stack>
#include<algorithm>
using namespace std;
//stack<t> stk; 采用模板类实现，stack对象的默认构造形式
//stack(const stack& stk); l / 拷贝构造函数
//赋值操作：
//stack & operator=(const stack & stk); //重载等号操作符
//数据存取：
//push(elem); //向栈顶添加元素
//基本接口
//pop(); / 从栈顶移除第一个元素
//top(); //返回栈顶元素
//大小操作：
//empty(); //判断堆栈是否为空
//size(); // 返回栈的大小
void test1()
{
stack <int>a;//没有遍历行为
a.push(1);
a.push(2);
a.push(3);
a.push(4);
stack<int> b;
b = a;
b.pop();
cout << "a的栈顶元素为" << a.top() << endl;
cout << "b的栈顶元素为" << b.top() << endl;
if (a.empty())
{
cout << "为空" << endl;
}
else {
cout << "a的大小为:" << a.size() << endl;
}
}
int main() {
test1();
return 0;
}
queue容器
queue是一种先进先出的数据结构，有两个出口。
队列容器允许从一端新增元素，从另一端移除元素
队列中只有队头和队尾才可以被外界使用，因此队列不允许有遍历行为
队列中进数据称为--入队 push
构造
构造函数：
queue<t> que; //queue采用模板类实现，queue对象的默认构造形式
queue(const queue &que); //拷贝构造函数
赋值
赋值操作：
queue& operator=(const queue &que); 1/重载等号操作符
存取
数据存取：
push(elem); //往队尾添加元素
pop(); //从队头移除第一个元素
back(); //返回最后一个元素
front(); //返回第一个元素
大小
大小操作：
empty(); /判断堆栈是否为空size(): /返回栈的大小
代码示例：
#include<iostream>
#include<queue>
#include<algorithm>
using namespace std;
//构造函数：
//queue<t>que; //queue采用模板类实现，queue对象的默认构造形式
//queue(const queue& que); //拷贝构造函数
//赋值操作：
//queue& operator=(const queue& que); // 重载等号操作符
//数据存取：
//push(elem); // 往队尾添加元素
//pop(); //从队头移除第一个元素
//back(); //返回最后一个元素
//front(); //返回第一个元素
//大小操作：
//empty(); / 判断堆栈是否为空
//size() : / 返回栈的大小
void test1()
{
queue<int> a;
a.push(5);
a.push(4);
a.push(3);
a.push(2);
a.push(1);
a.pop();
cout << a.back() << endl;
cout << a.front() << endl;
if (a.empty()) {
cout << "为空" << endl;
}
else {
cout << "大小为" << a.size() << endl;
}
}
int main() {
test1();
return 0;
}
list容器
将数据链式存储起来
优点：
可以对任意位素进行快速插入或删除元素
缺点：
容器遍历速度，没有数组快
占用空间比数组大
创建
list<T>lis: //list采用采用模板类实现，对象的默认构造形式：
list(beg.end): /构造函数(beg.,end)//区间中的元素拷贝给本身。
list(n,elem): //构造函数将n个elem拷贝给本身。
list(const list&lis). //拷贝构造函数。代码示例：
#include<iostream> #include<list> #include<algorithm> using namespace std; //list<T>lis: //list采用采用模板类实现，对象的默认构造形式： //list(beg.end) : / 构造函数(beg., end)//区间中的元素拷贝给本身。 //list(n, elem) : //构造函数将n个elem拷贝给本身。 // list(const list & lis). //拷贝构造函数。 void pri(list<int>& a) { for (list<int>::iterator it = a.begin(); it != a.end(); it++) { cout << *it; }cout << endl; } void test1() { list <int> a; a.push_back(1); a.push_back(2); a.push_back(3); a.push_back(4); a.push_back(5); list<int>b(a.begin(), a.end()); list<int>c(5, 3); list<int>d = a; pri(a); pri(b); pri(c); pri(d); } int main() { test1(); return 0; }
赋值
assign(beg,end): /将【beg,end)区间中的数据拷贝赋值给本身。
assign(n,elem): //将n个elem拷贝赋值给本身。
list&operator(const list&lst) //重载等号操作符
swap(st) 将st与本身的元素互换。代码案例：
#include<iostream> #include<list> #include<algorithm> using namespace std; //assign(beg, end) : / 将【beg, end)区间中的数据拷贝赋值给本身。 //assign(n, elem) : //将n个elem拷贝赋值给本身。 //list & operator(const list& lst) //重载等号操作符 //swap(st) 将st与本身的元素互换。 void pri(list<int>& a) { for (list<int>::iterator it = a.begin(); it != a.end(); it++) { cout << *it; }cout << endl; } void test1() { list<int> a; a.assign(5, 3); pri(a); list <int> b; b = a; pri(b); list<int> c; int i = 0; for (;i < 5; i++) { c.push_back(i); } pri(c); a.assign(c.begin(),c.end()); pri(a); } int main() { test1(); return 0; }
大小
size(): //返回容器中元素的个数
empty(): /判断容器是否为空
resize(num) /重新指定容器的长度为mnum,若容器变长，以默认值填充新位置
/如果容器变短，见末尾超出容器长度的元素被删除。
resize(num,elem), /重新指定容器的长度为mum,若容器变长，以elem值填充新位置，
/如果容器变短，则末尾超出容器长度的元素被删除。代码案例：
#include<iostream> #include<list> #include<algorithm> using namespace std; //size() : //返回容器中元素的个数 // empty() : / 判断容器是否为空 // resize(num) / 重新指定容器的长度为mnum, 若容器变长，以默认值填充新位置 // / 如果容器变短，见末尾超出容器长度的元素被删除。 // resize(num, elem), / 重新指定容器的长度为mum, 若容器变长，以elem值填充新位置， // / 如果容器变短，则末尾超出容器长度的元素被删除。 void pri(list<int>& a) { for (list<int>::iterator it = a.begin(); it != a.end(); it++) { cout << *it; }cout << endl; } void test1() { list<int> a; a.assign(5, 3); pri(a); if (a.empty()) { cout << "为空" << endl; } else { cout << "a的大小为" << a.size() << endl; } a.resize(3); pri(a); a.resize(5,3); pri(a); } int main() { test1(); return 0; }
插入和删除
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值匹配的元素。
⭐注意：这个insert里的pos函数不是直接的数字，而是迭代器
代码案例：
#include<iostream> #include<list> #include<algorithm> using namespace std; //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值匹配的元素。 void pri(list<int>& a) { for (list<int>::iterator it = a.begin(); it != a.end(); it++) { cout << *it; }cout << endl; } void test1() { list<int> a; a.push_back(1); a.push_back(2); a.push_back(3); a.push_back(4); a.push_back(5); a.push_back(2); pri(a);//123452 a.pop_back(); pri(a);//12345 list<int> b; b.assign(5, 1); a.insert(a.begin(),1); pri(a);//112345 a.insert(a.begin(), 3, 0); pri(a);//000112345 a.insert(a.end(), b.begin(), b.end()); pri(a);//00011234511111 a.erase(a.begin()); pri(a);//0011234511111 a.remove(1); pri(a);//002345 } int main() { test1(); return 0; }
存取
对list容器中数据进行存取
函数原型：
front(): //返回第一个元素。
back(): //返回最后一个元素。代码案例:
#include<iostream> #include<list> #include<algorithm> using namespace std; //front() : //返回第一个元素。 //back() : //返回最后一个元素。 void pri(list<int>& a) { for (list<int>::iterator it = a.begin(); it != a.end(); it++) { cout << *it; }cout << endl; } void test1() { list<int> a; a.push_back(1); a.push_back(2); a.push_back(3); a.push_back(4); a.push_back(5); a.push_back(2); cout << "a的最后一个元素为" << a.back()<<endl; cout << "a的第一个元素为" << a.front() << endl; } int main() { test1(); return 0; }
迭代器
迭代器是不支持随机访问的
排序
reverse（) /反转链表
sort(): //链表排序代码示例;
#include<iostream> #include<list> #include<algorithm> using namespace std; //reverse（) / 反转链表 //sort() : //链表排序 void pri(list<int>& a) { for (list<int>::iterator it = a.begin(); it != a.end(); it++) { cout << *it; }cout << endl; } void test1() { list<int> a; a.push_back(1); a.push_back(2); a.push_back(3); a.push_back(4); a.push_back(5); a.reverse(); pri(a); list<int> b; b.push_back(3); b.push_back(4); b.push_back(6); b.push_back(1); b.sort(); pri(b); } int main() { test1(); return 0; }
set容器/multiset容器
简介
所有元素都会在插入时自动被排序
本质：
setmultset属于关联式容器，底层结构是用二叉树实现。
区别
set和multiset区别：
set不许容器中有重复的元素
multiset允许容器中有重复的元素因为：
set插入数据的同时会返回插入结果，表示插入是否成功
multiset不会检测数据，因此可以插入重复数据
示例：
#include<iostream>
#include<set>
#include<algorithm>
using namespace std;
void pri(set<int>& a)
{
for (set<int>::iterator it = a.begin(); it != a.end(); it++)
{
cout << *it;
}cout << endl;
}
void pri2(multiset<int>& a)
{
for (multiset<int>::iterator it = a.begin(); it != a.end(); it++)
{
cout << *it;
}cout << endl;
}
void test1()
{
set<int> a;
a.insert(1);
a.insert(2);
a.insert(3);
a.insert(4);
pri(a);
multiset<int> b;
b.insert(1);
b.insert(1);
b.insert(1);
b.insert(1);
b.insert(1);
pri2(b);
}
int main() {
test1();
return 0;
}
构造
构造：
set<t>st: /默认构造函数：
set(const set&st): /拷贝构造函数
代码示例：#include<iostream> #include<set> #include<algorithm> using namespace std; //构造： //set<t>st: / 默认构造函数： //set(const set & st) : / 拷贝构造函数 void pri(set<int>& a) { for (set<int>::iterator it = a.begin(); it != a.end(); it++) { cout << *it; }cout << endl; } void test1() { set<int> a; a.insert(a.begin(), 1); pri(a); set<int> b(a); pri(b); } int main() { test1(); return 0; }
赋值
赋值：
set&operator=(const set&st) 重载等号操作符代码示例：
#include<iostream> #include<set> #include<algorithm> using namespace std; //赋值 void pri(set<int>& a) { for (set<int>::iterator it = a.begin(); it != a.end(); it++) { cout << *it; }cout << endl; } void test1() { set<int> a; a.insert(a.begin(), 1); pri(a); set<int> b; b = a; pri(b); } int main() { test1(); return 0; }
大小
size(): //返回容器中元素的数目
empty(): //判断容器是否为空
swap(st): //交换两个集合容器代码示例：
#include<iostream> #include<set> #include<algorithm> using namespace std; //size() : //返回容器中元素的数目 // empty() : //判断容器是否为空 // swap(st) : //交换两个集合容器 void pri(set<int>& a) { for (set<int>::iterator it = a.begin(); it != a.end(); it++) { cout << *it; }cout << endl; } void test1() { set<int> a; a.insert(a.begin(), 1); if (a.empty()) { cout << "a为空" << endl; } else { cout << a.size() << endl; } set<int> b; b.insert(b.begin(), 2); cout << "交换前" << endl; pri(a); pri(b); b.swap(a); cout << "交换后" << endl; pri(a); pri(b); } int main() { test1(); return 0; }
插入和删除
insert（elem): 在容器中插入元素。
clear(): //清除所有元素
erase(pos): /删除pos送代器所指的元素，返回下一个元素的法代器。
erase(beg.end): /除区间beg.end的所有元素，返回下一个元素的送代器。
erase(elem): //删除容器中值为elem的元素。代码示例：
#include<iostream> #include<set> #include<algorithm> using namespace std; //insert（elem): 在容器中插入元素。 //clear() : //清除所有元素 //erase(pos) : / 删除pos送代器所指的元素，返回下一个元素的法代器。 //erase(beg，end) : / 除区间beg.end的所有元素，返回下一个元素的送代器。 //erase(elem) : //删除容器中值为elem的元素。 void pri(set<int>& a) { for (set<int>::iterator it = a.begin(); it != a.end(); it++) { cout << *it; }cout << endl; } void test1() { set<int> a; a.insert(1); a.insert(2); a.insert(3); a.insert(4); pri(a); set<int> b = a; a.clear(); pri(b); pri(a); b.erase(2); pri(b); } int main() { test1(); return 0; }
统计数据
find(key);
//查找key是否存在，若存在，返回该键的元素的迭代器；若不存在，返回set.end（);
count(key); //统计key的元素个数count由于不可以出现重复数据，则返回要么0或者1
#include<iostream> #include<set> #include<algorithm> using namespace std; // find(key); //查找key是否存在，若存在，返回该键的元素的迭代器；若不存在，返回set.end（); //count(key); //统计key的元素个数 void pri(set<int>& a) { for (set<int>::iterator it = a.begin(); it != a.end(); it++) { cout << *it; }cout << endl; } void test1() { set<int> a; a.insert(1); a.insert(2); a.insert(3); a.insert(4); int c=a.count(2); cout << c << endl;//1 if (a.find(2) != a.end()) { cout << "2存在" << endl; } else { cout << "2不存在" << endl; } } int main() { test1(); return 0; }
sort排序规则如何改变
对于函数sort而言，它一般只会把容器排序成升序的，那么怎么实现将容器排序成降序。
——用仿函数
仿函数的概念到下面讲解stl的函数对象时在细细讲解，这里你只需要知道，这是通过仿函数来实现的。
构建一个类，类里有一个重载函数调用的函数
class Mycompare
{
public:
bool operator()(int a,int b){
return a>b;
}
};
在写sort时，把这个类的类名写在最后一个，也就是第三个参数上， 这样就可以把sort排序变为降序排列了。
pair对组
成对出现的数据，利用对组可以返回两个数据
两种创建方式：
pair<type,type>p(value1,value2);
pair<type, type> p= make_pair( value1, value2);
返回两个数据——用队组
调用用.first和.second
代码示例：
#include<iostream>
#include<string>
#include<stdlib.h>
using namespace std;
void test2()
{
pair<string, int>a("小红",14);
cout << a.first << a.second << endl;
pair<string, int>b = make_pair("小寒", 23);
cout << b.first << b.second << endl;
}
int main() {
test2();
system("pause");
return 0;
}map容器/multimap容器
简介
简介：
map中所有元素都是pair对组
pair中第一个元素为key(键值）,起到索引作用，第二个元素为value(实值）
所有元素都会根据元素的键值自动排序
本质
本质：
map/multimap属于关联式容器，底层结构是用二叉树实现。
优点
优点：
可以根据key值快速找到value值
区别
map和multimap区别：
map不允许容器中有重复key值元素
multimap允许容器中有重复key值元素
构造和赋值
构造：
map<t1,t2>mp; /map默认构造函数：
map(const map &mp); //拷贝构造函数
赋值：
map& operator=(const map &mp); //重载等号操作符注意：⭐遍历的方法：
代码示例：
#include<iostream>
#include<map>
#include<algorithm>
using namespace std;
void printMap(map<int, int>& a)
{
for (map<int, int>::iterator it = a.begin(); it!= a.end();it++)
{
cout << "key= " << it->first << " value=" << it->second << endl;
}
}
void test1()
{
//创建map容器
map<int, int> a;
a.insert(pair<int,int>(0,12));
a.insert(pair<int, int>(2, 14));
a.insert(pair<int, int>(3, 23));
a.insert(pair<int, int>(1, 2));
a.insert(pair<int, int>(4, 45));
//printMap(a);
map<int, int>b;
b = a;
printMap(b);
}
int main() {
test1();
return 0;
}大小
size(); //返回容器中元素的数目
empty(); //判断容器是否为空
swap(st); //交换两个集合容器
插入和删除
insert(elem); //在容器中插入元素。这个里面要写pair数组来赋值插入
clear(); //清除所有元素
erase(pos); //删除pos迭代器所指的元素，返回下一个元素的迭代器。
erase(beg,end); //删除区间（beg,end)的所有元素，返回下一个元素的迭代器。
erase(key); //删除容器中值为key的元素。
插入数组代码示例：
#include<iostream> #include<map> #include<algorithm> using namespace std; //高效率，高性能，因为有个key起索引作用 //且会直接按照key值排序 //底层来用二叉树实现的 //map的key值不可重复，value可以重复 void printMap(map<int, int>& a) { for (map<int, int>::iterator it = a.begin(); it!= a.end();it++) { cout << "key= " << it->first << " value=" << it->second << endl; } } void test1() { map<int, int> a; a.insert(pair<int,int>(0,12)); a.insert(pair<int, int>(2, 14)); a.insert(pair<int, int>(3, 23)); a.insert(pair<int, int>(1, 2)); a.insert(pair<int, int>(4, 45)); printMap(a); } int main() { test1(); return 0; }
查找
find(key); //查找key是否存在，返回该键的元素的元素的迭代器；若不存在，返回set.end();
count(key); //统计key的元素个数count和set里的一样，由于不可以出现重复数据，则返回要么0或者1
变排序规则
利用仿函数来改变排序规则——
注意：如果把不改变数据成员的函数都加上const关键字进行标识，显然可提高程序的可读性。 其实，它还能提高程序的可靠性，已定义成const的成员函数，一旦企图修改数据成员的值，则编译器按错误处理。
代码示例：
#include<iostream>
#include<map>
#include<stdlib.h>
using namespace std;
class MyCompare
{
public:
bool operator()(int m, int n)const//要加一个const，对于不同的编译器可能不一样，这个如果不加，就发生错误
{
return m > n;
}
};
void test2()
{
map<int,int,MyCompare> a;
a.insert(make_pair(1, 10));
a.insert(make_pair(2, 20));
a.insert(make_pair(3, 30));
a.insert(make_pair(4, 40));
a.insert(make_pair(5, 50));
for (map<int,int,MyCompare>::iterator it = a.begin(); it != a.end(); it++)
{
cout << "key= " << it->first << " value=" << it->second << endl;
}
}
int main() {
test2();
system("pause");
return 0;
}
🎄STL函数对象
函数对象
概念：
一个类重载了函数调用符号——()，然后其类对象可以进行类似于函数调用的操作，因此被称为函数对象
而函数对象进行调用操作由于比较像函数调用嘛又被称为仿函数
注意：这里所有的函数对象阿、仿函数等概念都是指一个类
区别和共性：
由于它并不是真正的函数调用，因此会有几点区别但也有一样的地方——
1.函数对象可以有自己的属性，而普通函数没有
2.函数对象可以像普通函数调用一样有参数，有返回值
3.函数对象可以作为参数传递
谓词
谓词就是在函数对象的基础上加上一个条件——返回类型为bool类型
而且分为两类：
参数为1个的——一元谓词
参数为2个的——二元谓词
内置的函数对象
对于c++，编译器会有一些内置的函数对象，不过需要加头文件——#include<function>
分类：
算数仿函数
实现四则运算的函数对象（仿函数）
仿函数原型:
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>//取反仿函数
只有取反的是一元函数，其余皆为二元
代码示例：
#include<iostream>
#include<functional>
using namespace std;
//内建函数对象——算数仿函数
//1.取反仿函数
//2.加法仿函数
void test1()
{
negate<int> a;//创建的函数对象
cout << a(10) << endl;//-10
plus<int>b;//只写一个数据类型
cout << b(1, 2) << endl;//3
}
int main() {
test1();
return 0;
}关系仿函数
实现关系对比的仿函数
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>//小于等于
代码示例：——通过大于的关系仿函数来实现降序排列
#include<iostream>
#include<functional>
#include<vector>
#include<algorithm>
using namespace std;
//内建函数对象——关系仿函数
class MYcompare
{
public:
bool operator()(int a, int b)
{
return a > b;
}
};
void test1()
{
vector <int> v;
v.push_back(1);
v.push_back(5);
v.push_back(2);
v.push_back(4);
v.push_back(3);
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
{
cout << *it;
}cout << endl;
sort(v.begin(), v.end(), MYcompare());//自己创建的仿函数来实现降序
sort(v.begin(), v.end(), greater<int>());//内建函数对象
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
{
cout << *it;
}cout << endl;
}
int main() {
test1();
return 0;
}逻辑仿函数
实现逻辑运算的仿函数
template<class T> bool logical and<T>//逻辑与
template<class T> bool logical or<T>//逻辑或
template<class T> bool logical not<T>//逻辑非
在实际开发中基本用不到
代码案例：
#include<iostream>
#include<functional>
#include<vector>
#include<algorithm>
using namespace std;
//内建函数对象——关系仿函数
void test1()
{
vector <int> v;
v.push_back(true);//1
v.push_back(false);//0
v.push_back(true);//1
v.push_back(true);//1
v.push_back(false);//0
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
{
cout << *it;
}cout << endl;
vector <int>b;
b.resize(v.size());//要提前开辟一块空间，再搬运
transform(v.begin(), v.end(), b.begin(),logical_not<bool>());//这是个内置的函数
for (vector<int>::iterator it = b.begin(); it != b.end(); it++)
{
cout << *it;
}cout << endl;
}
int main() {
test1();
return 0;
}
🎄STL算法
这里介绍一些比较常用的算法——一般需要包含的头文件是——<algorithm>
常用算法：
1.遍历算法
for_each
for_each(iterator begin,iterator end,func)
三个参数分别是——开始的迭代器，终止迭代器，函数或者函数对象
transform
将一个容器里的内容搬运到另一个容器中
transform(iterator begin1,iterator end1,iterator begin2 ,func)
参数分别对应原容器起始迭代器，原终止迭代器，新容器起始迭代器，函数或是函数对象
2.查找算法
find
查找目标元素，找到返回指定元素的迭代器，找不到返回终止迭代器
end()find(iterator begin.iterator end,val);
分别对应着起始迭代器、终止迭代器、目标元素
find_if
按条件查找元素，找到返回所在位置迭代器，否则返回终止迭代器end()；
find_if(iterator begin,iterator end,_Pred)
begin 起始迭代器
end 终止迭代器
_Pred 函数或谓词adjacent_find
查找相邻重复元素，找到返回所在位置迭代器，否则返回终止选代器end();
adjacent find(iterator begin,iterator end);
起始迭代器，终止迭代器
binary_search
查找指定元素是否存在，存在返回true，否则返回false
binary_search(iterator begin,iterator end,val);
分别代表：起始迭代器、终止迭代器、目标元素
count
统计元素个数
count(iterator begin,iterator end,val);参数分别为：起始迭代器、终止迭代器、目标元素
count_if
按条件统计元素个数
count_if(iterator begin,iterator end,_Pred);起始迭代器、终止迭代器、谓词(也就是条件)
3.排序算法
sort
对容器内元素进行排序
sort(iterator begin,iterator end, Pred);
起始迭代器、终止迭代器、谓词(条件，不填是升序)
random_shuffle
洗牌，指定范围内元素随机调整次序
random shuffle(iterator begin,iterator end);起始迭代器、终止迭代器
merge
将两个容器元素合并，并存储到另一个容器中
merge(iterator begin1,iterator end1,iterator begin2,iterator end2,iterator dest);
参数分别为： 容器1起始迭代器、 容器1终止迭代器、容器2起始迭代器、容器2终止迭代器、目标存储迭代器
reverse
将范围内元素反转
reverse(iterator begin,iterator end);起始迭代器、终止迭代器
4.拷贝和替换函数
copy
将容器指定范围内元素拷贝到另一容器中
copy(iterator begin1,iterator end1,iterator dest);
begin1 容器1起始迭代器
end1 容器1终止迭代器
dest 目标存储迭代器
replace
将容器中指定范围内的所有指定元素替换为新的元素
replace(iterator begin,iterator end,oldval,newval);
begin 起始迭代器
end 终止迭代器
oldval 旧元素
newval 新元素replace_if
容器内指定范围内满足条件的元素替换为新的元素
replace_if(iterator begin,iterator end,_Pred,newval); begin 起始迭代器 end 终止迭代器 _Pred 谓词 newval 新元素
swap
交换2个相同类型容器的元素
swap(container c1,container c2);
c1 容器1
c2 容器2
5.算术生成算法
fill
向容器中添加指定元素
fill(iterator begin,iterator end,val);
begin 起始迭代器
end 终止迭代器
val 要填充的值
accumulate
将容器指定范围内元素拷贝到另一容器中
accumulate(iterator begin,iterator end,val);
begin 起始迭代器
end 终止迭代器
val 起始值
6.集合算法
set_intersection
求两个容器的交集
set_intersection(iterator begin1,iterator end1,iterator begin2,iterator end2,iterator dest);
begin1 容器1起始迭代器
end1 容器1终止迭代器
begin2 容器2起始迭代器
end2 容器2终止迭代器
dest 目标存储迭代器
🎄总结
到这里已经基本总结完毕了有关c++的stl知识，由于文章篇幅比较长，有些细节没有很完善，本篇文章会继续更新，欢迎收藏，跟进后续内容。(●'◡'●)
541
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
