C++提高编程----STL标准模板库-常用容器
STL标准模板库(Standard Template Library)-常用容器
C++的,面向对象和泛型编程,目的就是提高代码的复用性;为了建立数据结构和算法的统一标准,诞生了STL
一、STL初识
(1)STL基本概念:
- STL 从广义上分为: 容器(container) 算法(algorithm) 迭代器(iterator)
- 容器和算法之间通过迭代器进行无缝连接
- STL 几乎所有的代码都采用了模板类或者模板函数
(2)STL六大组件
容器、算法、迭代器、仿函数、适配器(配接器)、空间配置器
容器:各种数据结构,用来存放数据,如vector、list、deque、set、map等;
算法:各种常用的算法,如sort、find、copy、for_each等;
迭代器:扮演了容器与算法之间的胶合剂;
仿函数:行为类似函数,可作为算法的某种策略;
适配器:一种用来修饰容器或者仿函数或迭代器接口的东西;
空间配置器:负责空间的配置与管理;
(3)STL中的容器、算法、迭代器
容器:实现出各种数据结构,用来存放数据(常用的数据结构有,数组,链表,树,栈,队列,集合,映射表等);
序列式容器:强调值的排序,每个元素均有固定的位置;
关联式容器:二叉树结构,各元素之间没有严格上的物理顺序;
算法:有限的步骤,解决逻辑上的或数学上的问题,这一门学科我们叫做算法(Algorithms);
质变算法:是指运算过程中会更改区间内的元素的内容;(例如拷贝,替换,删除等)
非质变算法:是指运算过程中不会更改区间内的元素内容;(例如查找、计数、遍历、寻找极值等)
迭代器:容器和算法之间粘合剂;(用来遍历容器中的元素);
每一个容器都有自己的迭代器,迭代器是用来遍历容器中的元素;
常用的迭代器为双向迭代器,和随机访问迭代器;
迭代器的种类:
种类 | 功能 | 支持运算 |
---|---|---|
输入迭代器 | 对数据的只读访问 | 只读,支持++、==、!= |
输出迭代器 | 对数据的只写访问 | 只写,支持++ |
前向迭代器 | 读写操作,并能向前推进迭代器 | 读写,支持++、==、!= |
双向迭代器 | 读写操作,并能向前和向后操作 | 读写,支持++、–, |
随机访问迭代器 | 读写操作,可以以跳跃的方式访问任意数据,功能最强的迭代器 | 读写,支持++、–、[n]、-n、<、<=、>、>= |
二、STL-常用容器
1、vector容器(有的人叫它,数组)
先来看3个实例,熟悉一下vector容器:
vector存放基本数据类型,并打印输出
容器: vector
算法: for_each
迭代器: vector<int>::iterator
#include <vector>
#include <algorithm>void MyPrint(int val)
{cout << val << endl;
}void test01() {//创建vector容器对象,并且通过模板参数指定容器中存放的数据的类型vector<int> v;//向容器中放数据v.push_back(10);v.push_back(20);v.push_back(30);v.push_back(40);//每一个容器都有自己的迭代器,迭代器是用来遍历容器中的元素//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 << endl;pBegin++;}//第二种遍历方式:for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {cout << *it << endl;}cout << endl;//第三种遍历方式://使用STL提供标准遍历算法 头文件 algorithmfor_each(v.begin(), v.end(), MyPrint);
}int main() {test01();system("pause");return 0;
}
vector存放自定义数据类型,并打印输出
#include <vector>
#include <string>//自定义数据类型
class Person {
public:Person(string name, int age) {mName = name;mAge = age;}
public:string mName;int mAge;
};
//存放对象
void test01() {vector<Person> v;//创建数据Person p1("aaa", 10);Person p2("bbb", 20);Person p3("ccc", 30);Person p4("ddd", 40);Person p5("eee", 50);v.push_back(p1);v.push_back(p2);v.push_back(p3);v.push_back(p4);v.push_back(p5);for (vector<Person>::iterator it = v.begin(); it != v.end(); it++) {cout << "Name:" << (*it).mName << " Age:" << (*it).mAge << endl;}
}//放对象指针
void test02() {vector<Person*> v;//创建数据Person p1("aaa", 10);Person p2("bbb", 20);Person p3("ccc", 30);Person p4("ddd", 40);Person p5("eee", 50);v.push_back(&p1);v.push_back(&p2);v.push_back(&p3);v.push_back(&p4);v.push_back(&p5);for (vector<Person*>::iterator it = v.begin(); it != v.end(); it++) {Person * p = (*it);cout << "Name:" << p->mName << " Age:" << (*it)->mAge << endl;}
}int main() {test01();test02();system("pause");return 0;
}
vector容器嵌套容器,并遍历输出
#include <vector>//容器嵌套容器
void test01() {vector< vector<int> > v;vector<int> v1;vector<int> v2;vector<int> v3;vector<int> v4;for (int i = 0; i < 4; i++) {v1.push_back(i + 1);v2.push_back(i + 2);v3.push_back(i + 3);v4.push_back(i + 4);}//将容器元素插入到vector v中v.push_back(v1);v.push_back(v2);v.push_back(v3);v.push_back(v4);for (vector<vector<int>>::iterator it = v.begin(); it != v.end(); it++) {for (vector<int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++) {cout << *vit << " ";}cout << endl;}}int main() {test01();system("pause");return 0;
}
(1)vector基本概念:(有的人叫它,数组)
- vector数据结构和数组非常相似,数组是静态空间,而vector可以动态扩展,vector也被称为单端数组(尾端进行插入删除效率高,头部进行插入删除效率低);
- 动态扩展并不是在原空间之后续接新空间,而是找一个更大的内存空间,然后将原数据拷贝到新空间,释放原空间;
- vector容器的迭代器是支持随机访问的迭代器;
(2)vector构造函数
功能:创建vector容器
函数原型:
vector<T> v;
// 默认构造;vector(v.begin(), v.end());
// 区间构造,将 v[begin(), end()) 区间中的元素拷贝给本身;vector(n, elem);
// 将n个elem拷贝给本身;(n是个数,elem是值)vector(const vector &vec);
// 拷贝构造;
示例:使用时包含头文件 vector
#include <vector>// 遍历容器中的元素
void printVector(vector<int>& v) {for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {cout << *it << " ";}cout << endl;
}void test01()
{// 1、默认构造,也叫无参构造vector<int> v1; for (int i = 0; i < 10; i++){v1.push_back(i);}printVector(v1);// 2、通过区间方式进行构造vector<int> v2(v1.begin(), v1.end());printVector(v2);// 3、n个elem方式构造vector<int> v3(10, 100);printVector(v3);// 4、拷贝构造,利用v3来初始化出v4vector<int> v4(v3);printVector(v4);
}int main() {test01();system("pause");return 0;
}
(3)vector赋值操作
功能:给vector容器赋值
函数原型:
vector& operator=(const vector &vec);
// 等号赋值;assign(begin, end);
// assign()区间赋值,将[begin, end)区间中的数据,赋值给本身;assign(n, elem);
// assign()赋值,将n个elem赋值给本身;(n是个数,elem是值)
示例:使用时包含头文件 vector
#include <vector>void printVector(vector<int>& v) {for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {cout << *it << " ";}cout << endl;
}//赋值操作
void test01()
{vector<int> v1;for (int i = 0; i < 10; i++){v1.push_back(i);}printVector(v1);// 1、等号赋值vector<int>v2;v2 = v1;printVector(v2);// 2、assign()区间赋值vector<int>v3;v3.assign(v1.begin(), v1.end());printVector(v3);// 3、assign()赋值,n个elem方式构造vector<int>v4;v4.assign(10, 100);printVector(v4);
}int main() {test01();system("pause");return 0;
}
(4)vector的容量和大小
功能:对vector容器的容量和大小操作
函数原型:
empty();
// 判断容器是否为空;capacity();
// 返回容器的容量;size();
// 返回容器中元素的个数;resize(int num);
// 重新指定容器的长度为num(若容器变长则以默认值填充新位置,如果容器变短则末尾超出容器长度的元素被删除);resize(int num, elem);
// 重新指定容器的长度为num(若容器变长则以elem值填充新位置,如果容器变短则末尾超出容器长度的元素被删除);
示例:使用时包含头文件 vector
#include <vector>void printVector(vector<int>& v) {for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {cout << *it << " ";}cout << endl;
}void test01()
{vector<int> v1;for (int i = 0; i < 10; 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;}// resize 重新指定大小,若指定的更大,则默认用0填充新位置v1.resize(15,10);printVector(v1);// resize 重新指定大小,若指定的更小,则末尾超出容器长度的元素被删除v1.resize(5);printVector(v1);
}int main() {test01();system("pause");return 0;
}
(5)vector插入和删除
功能:对vector容器进行插入、删除操作
函数原型:
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();
// 删除容器中所有元素
示例:使用时包含头文件 vector
#include <vector>void printVector(vector<int>& v) {for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {cout << *it << " ";}cout << endl;
}//插入和删除
void test01()
{vector<int> v1;// 尾插 — push_backv1.push_back(10);v1.push_back(20);v1.push_back(30);v1.push_back(40);v1.push_back(50);printVector(v1);// 尾删 — pop_backv1.pop_back();printVector(v1);// 插入 — insert (位置迭代器)v1.insert(v1.begin(), 100);printVector(v1);v1.insert(v1.begin(), 2, 1000);printVector(v1);// 删除 — erase (位置迭代器)v1.erase(v1.begin());printVector(v1);// 清空 — clearv1.erase(v1.begin(), v1.end());v1.clear();printVector(v1);
}int main() {test01();system("pause");return 0;
}
(6)vector数据存取
功能:对vector中的数据进行存取操作
函数原型:
at(int i);
// 返回索引 i 所指的数据[int i];
// 返回索引 i 所指的数据front();
// 返回容器中第一个数据元素back();
// 返回容器中最后一个数据元素
示例:使用时包含头文件 vector
#include <vector>void test01()
{vector<int>v1;for (int i = 0; i < 10; i++){v1.push_back(i);}// 除了用迭代器获取vector容器中元素,[]和at也可以for (int i = 0; i < v1.size(); i++){cout << v1[i] << " ";}cout << endl;for (int i = 0; i < v1.size(); i++){cout << v1.at(i) << " ";}cout << endl;// front返回容器第一个元素cout << "v1的第一个元素为: " << v1.front() << endl;// back返回容器最后一个元素cout << "v1的最后一个元素为: " << v1.back() << endl;
}int main() {test01();system("pause");return 0;
}
(7)vector互换容器
功能:swap() 可以实现两个容器内元素互换,达到收缩内存空间的效果
函数原型:
swap(vec);
// 将vec与本身的元素互换
示例:使用时包含头文件 vector
#include <vector>void printVector(vector<int>& v) {for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {cout << *it << " ";}cout << endl;
}// 1、基本使用
void test01()
{vector<int>v1;for (int i = 0; i < 10; i++){v1.push_back(i);}vector<int>v2;for (int i = 10; i > 0; i--){v2.push_back(i);}cout << "互换前:" << endl;printVector(v1);printVector(v2);// 互换容器cout << "互换后:" << endl;v1.swap(v2);printVector(v1);printVector(v2);
}// 2、实际用途,巧用swap()可以收缩内存空间
void test02()
{vector<int> v;for (int i = 0; i < 100000; i++) {v.push_back(i);}cout << "v的容量为:" << v.capacity() << endl;cout << "v的大小为:" << v.size() << endl;// 重新指定容器的长度为3v.resize(3);cout << "v的容量为:" << v.capacity() << endl;cout << "v的大小为:" << v.size() << endl;// 使用swap()收缩内存空间vector<int>(v).swap(v);cout << "v的容量为:" << v.capacity() << endl;cout << "v的大小为:" << v.size() << endl;
}int main() {test01();test02();system("pause");return 0;
}
(8)vector预留空间
功能:减少vector在动态扩展容量时的扩展次数(如果数据量较大,可以一开始利用reserve() 预留空间)
函数原型:
reserve(int len);
// 容器预留len个元素长度的空间;
示例:使用时包含头文件 vector
#include <vector>void test01()
{vector<int> v;//利用reserve预留空间v.reserve(100000);int num = 0;int* p = NULL;for (int i = 0; i < 100000; i++) {v.push_back(i);if (p != &v[0]) {p = &v[0];num++;}}cout << "num:" << num << endl;
}int main() {test01();system("pause");return 0;
}
2、string容器
(1)string基本概念:
- string本质上是一个类, 类内部封装了很多成员方法(插入insert,删除delete,替换replace,查找find,拷贝copy)
- string内部管理着c语言风格的字符串char*;
- char* 本质上是一个指针;
(2)string构造函数:
功能:初始化一个字符串(string构造函数的作用,就是用来创建字符串);
string的构造函数原型:
string();
// 无参构造函数,创建一个空的字符串string(const char* s);
// 使用c语言风格的字符串s,来初始化出c++风格的字符串string(const string& str);
// 使用一个string对象初始化另一个string对象string(int n, char a);
// 使用n个字符a初始化一个字符串
示例:使用时包含头文件 string
#include <string>
// string构造函数
void test01()
{string s1; // 创建空字符串cout << "str1 = " << s1 << endl;const char* str = "hello world";string s2(str); // 使用c语言风格的字符串str,来初始化出c++风格的字符串s2cout << "str2 = " << s2 << endl;string s3(s2); //调用拷贝构造函数,利用字符串s2创建出字符串s3cout << "str3 = " << s3 << endl;string s4(6, 'a'); // 使用6个字符a初始化字符串s4cout << "str3 = " << s3 << endl;
}int main() {test01();system("pause");return 0;
}
(3)string赋值操作
功能:给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,赋给当前字符串
// 赋值, string的赋值方式很多,operator= 这种方式比较实用
void test01()
{// 方式1string str1;str1 = "hello world";cout << "str1 = " << str1 << endl;// 方式2string str2;str2 = str1;cout << "str2 = " << str2 << endl;// 方式3string str3;str3 = 'a';cout << "str3 = " << str3 << endl;// 方式4string str4;str4.assign("hello c++");cout << "str4 = " << str4 << endl;// 方式5string str5;str5.assign("hello c++",5);cout << "str5 = " << str5 << endl;// 方式6string str6;str6.assign(str5);cout << "str6 = " << str6 << endl;// 方式7string str7;str7.assign(5, 'x');cout << "str7 = " << str7 << endl;
}int main() {test01();system("pause");return 0;
}
(4)string字符串拼接
功能:给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个字符,连接到字符串结尾
//字符串拼接
void test01()
{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 abcde", 4);//str3.append(str2);str3.append(str2, 4, 3); // str2从下标4位置开始,截取3个字符,拼接到字符串str3末尾cout << "str3 = " << str3 << endl;
}
int main() {test01();system("pause");return 0;
}
(5)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个字符为字符串sfind查找是从左往后,rfind从右往左
find找到字符串后返回查找的第一个字符位置,找不到返回-1
replace在替换时,要指定从哪个位置起,多少个字符,替换成什么样的字符串
//查找和替换
void test01()
{//查找string str1 = "abcdefgde";int pos = str1.find("de");if (pos == -1){cout << "未找到" << endl;}else{cout << "pos = " << pos << endl;}pos = str1.rfind("de");cout << "pos = " << pos << endl;}void test02()
{//替换string str1 = "abcdefgde";str1.replace(1, 3, "1111");cout << "str1 = " << str1 << endl;
}int main() {//test01();//test02();system("pause");return 0;
}
(6)string字符串比较
功能:字符串之间的比较(字符串对比主要是用于比较两个字符串是否相等,判断谁大谁小的意义并不是很大)
比较方式:字符串之间的比较是按字符的ASCII码进行比较
= 返回 0
> 返回 1
< 返回 -1
函数原型:
int compare(const string &s) const;
// 与字符串s比较int compare(const char *s) const;
// 与字符串s比较
//字符串比较
void test01()
{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;}}int main() {test01();system("pause");return 0;
}
(7)string单个字符的存取
string字符串中单个字符存取有两种方式,利用 [ ] 或 at
char& operator[](int n);
// 通过 [] 方式 取字符char& at(int n);
// 通过 at 方法 取字符
void test01()
{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;
}int main() {test01();system("pause");return 0;
}
(8)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个字符
//字符串插入和删除
void test01()
{string str = "hello";str.insert(1, "111");cout << str << endl;str.erase(1, 3); //从1号位置开始3个字符cout << str << endl;
}int main() {test01();system("pause");return 0;
}
(9)string子串
功能:从字符串中获取想要的子串
函数原型:
string substr(int pos = 0, int n = npos) const;
// 返回由pos开始的n个字符组成的字符串
//子串
void test01()
{string str = "abcdefg";string subStr = str.substr(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;}int main() {test01();system("pause");return 0;
}
3、deque容器
(1)deque容器基本概念:
功能:双端数组,可以对头端进行插入删除,也可以对尾端进行插入删除;
deque与vector区别:
- vector对于头部的插入删除效率低,数据量越大,效率越低;
- deque相对而言,对头部的插入删除速度比vector快;
- vector访问元素时的速度会比deque快,这和两者内部实现有关;
deque内部工作原理:
- deque内部有个中控器,维护每段缓冲区中的内容,缓冲区中存放真实数据中控器维护的是每个缓冲区的地址,使得使用deque时像一片连续的内存空间
- deque容器的迭代器也是支持随机访问的
(2)deque构造函数:
功能:创建deque容器(初始化一个deque容器)
函数原型:deque容器和vector容器的构造方式几乎一样
deque<T>
deqT; // 默认构造;deque(v.begin(), v.end());
// 区间构造,将 v[begin(), end()) 区间中的元素拷贝给本身;deque(n, elem);
// 将n个elem拷贝给本身;(n是个数,elem是值);deque(const deque &deq);
// 拷贝构造;
示例:使用时包含头文件deque
#include <deque>// 打印输出函数
void printDeque(const deque<int>& d)
{for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {cout << *it << " ";}cout << endl;
}
//deque构造
void test01() {// 默认构造deque<int> d1; for (int i = 0; i < 10; i++){d1.push_back(i);}printDeque(d1);// 通过区间方式进行构造deque<int> d2(d1.begin(),d1.end());printDeque(d2);// 将n个elem拷贝给本身deque<int>d3(10,100);printDeque(d3);// 拷贝构造deque<int>d4 = d3;printDeque(d4);
}int main() {test01();system("pause");return 0;
}
(3)deque赋值操作:
功能:给deque容器赋值(deque赋值操作与vector赋值相同);
函数原型:
deque& operator=(const deque &deq);
// 等号赋值;assign(beg, end);
// assign()区间赋值,将[begin, end)区间中的数据,赋值给本身;assign(n, elem);
// assign()赋值,将n个elem赋值给本身;(n是个数,elem是值)
示例:使用时包含头文件deque
#include <deque>void printDeque(const deque<int>& d)
{for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {cout << *it << " ";}cout << endl;
}
//赋值操作
void test01()
{deque<int> d1;for (int i = 0; i < 10; i++){d1.push_back(i);}printDeque(d1);deque<int>d2;d2 = d1;printDeque(d2);deque<int>d3;d3.assign(d1.begin(), d1.end());printDeque(d3);deque<int>d4;d4.assign(10, 100);printDeque(d4);}int main() {test01();system("pause");return 0;
}
(4)deque大小操作:
功能:对deque容器的大小进行操作;
函数原型:
deque.empty();
// 判断容器是否为空;deque.size();
/// 返回容器中元素的个数;deque.resize(num);
// 重新指定容器的长度为num(若容器变长则以默认值填充新位置,如果容器变短则末尾超出容器长度的元素被删除);deque.resize(num, elem);
// 重新指定容器的长度为num(若容器变长则以elem值填充新位置,如果容器变短则末尾超出容器长度的元素被删除);
示例:使用时包含头文件deque
#include <deque>void printDeque(const deque<int>& d)
{for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {cout << *it << " ";}cout << endl;
}//大小操作
void test01()
{deque<int> d1;for (int i = 0; i < 10; i++){d1.push_back(i);}printDeque(d1);//1、判断容器是否为空if (d1.empty()) {cout << "d1为空!" << endl;}else {cout << "d1不为空!" << endl;// 2、返回容器中元素的个数cout << "d1的大小为:" << d1.size() << endl;}// 3、重新指定容器的长度为15(若容器变长则以 1值 填充新位置d1.resize(15, 1);printDeque(d1);// 4、重新指定容器的长度为5d1.resize(5);printDeque(d1);
}int main() {test01();system("pause");return 0;
}
(5)deque 插入和删除:
功能:向deque容器中插入和删除数据;
函数原型:
两端插入操作:
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位置的数据,返回下一个数据的位置;
示例:使用时包含头文件deque
#include <deque>void printDeque(const deque<int>& d)
{for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {cout << *it << " ";}cout << endl;
}
//两端操作
void test01()
{deque<int> 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);
}//插入
void test02()
{deque<int> d;d.push_back(10);d.push_back(20);d.push_front(100);d.push_front(200);printDeque(d);d.insert(d.begin(), 1000);printDeque(d);d.insert(d.begin(), 2,10000);printDeque(d);deque<int>d2;d2.push_back(1);d2.push_back(2);d2.push_back(3);d.insert(d.begin(), d2.begin(), d2.end());printDeque(d);}//删除
void test03()
{deque<int> d;d.push_back(10);d.push_back(20);d.push_front(100);d.push_front(200);printDeque(d);d.erase(d.begin());printDeque(d);d.erase(d.begin(), d.end());d.clear();printDeque(d);
}int main() {//test01();//test02();test03();system("pause");return 0;
}
(6)deque 数据存取:
功能:对vector中的数据进行存取操作
函数原型:
at(int i);
// 返回索引 i 所指的数据[int i];
// 返回索引 i 所指的数据front();
// 返回容器中第一个数据元素back();
// 返回容器中最后一个数据元素
示例:使用时包含头文件 deque
#include <deque>void printDeque(const deque<int>& d)
{for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {cout << *it << " ";}cout << endl;
}//数据存取
void test01()
{deque<int> d;d.push_back(10);d.push_back(20);d.push_front(100);d.push_front(200);// 返回索引 i 所指的数据for (int i = 0; i < d.size(); i++) {cout << d[i] << " ";}cout << endl;// 返回索引 i 所指的数据for (int i = 0; i < d.size(); i++) {cout << d.at(i) << " ";}cout << endl;// 返回容器中第一个数据元素cout << "front:" << d.front() << endl;// 返回容器中最后一个数据元素cout << "back:" << d.back() << endl;}int main() {test01();system("pause");return 0;
}
(7)deque 排序:
功能:利用算法实现对deque容器进行排序;
算法:
sort(iterator beg, iterator end)
// 对beg和end区间内的元素进行排序
示例:sort() 排序算法使用时包含头文件 algorithm
#include <deque>
#include <algorithm>void printDeque(const deque<int>& d)
{for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) {cout << *it << " ";}cout << endl;
}void test01()
{deque<int> d;d.push_back(10);d.push_back(20);d.push_front(100);d.push_front(200);printDeque(d);sort(d.begin(), d.end());printDeque(d);}int main() {test01();system("pause");return 0;
}
4、stack容器(也叫,栈容器,简称为,栈)
(1)stack容器的基本概念:
概念:stack容器(栈容器)只有一个出口,是一种先进后出(First In Last Out)的数据结构;
- 栈中只有顶端的元素才可以被外界使用,因此栈不允许有遍历行为;
- 栈中进入数据称为 — 入栈
push
- 栈中弹出数据称为 — 出栈
pop
(2)stack 常用接口
功能:栈容器常用的对外接口;
构造函数:创建栈容器(初始化一个栈容器)
stack<T> stk;
// 默认构造;stack(const stack &stk);
// 拷贝构造;
赋值操作:
stack& operator=(const stack &stk);
// 等号操作符
数据存取:
push(elem);
// 向栈顶添加元素pop();
// 从栈顶移除第一个元素top();
// 返回栈顶元素
大小操作:
empty();
// 判断栈是否为空size();
// 返回栈的大小
示例:使用时包含头文件stack
#include <stack>//栈容器常用接口
void test01()
{//创建栈容器 栈容器必须符合先进后出stack<int> 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 容器:(也叫,队列)
(1)queue 容器的基本概念:
概念:Queue容器(队列)有两个出口,是一种先进先出(First In First Out)的数据结构;
- 队列容器允许从一端新增元素,从另一端移除元素;
- 队列中只有队头和队尾的元素才可以被外界使用,因此队列不允许有遍历行为;
- 队列中进数据称为 — 入队
push
- 队列中出数据称为 — 出队
pop
(2)queue 容器常用接口
功能:queue容器常用的对外接口;
构造函数:创建queue容器(初始化一个queue容器)
queue<T> que;
// 默认构造;queue(const queue &que);
// 拷贝构造;
赋值操作:
queue& operator=(const queue &que);
// 等号赋值;
数据存取:
push(elem);
// 入队,往队尾添加一个元素pop();
// 出队,从队头移除一个元素back();
// 返回队尾元素front();
// 返回队头元素
大小操作:
empty();
// 判断队列是否为空size();
// 返回队列的大小
示例:使用时包含头文件queue
#include <queue>
#include <string>
class Person
{public:Person(string name, int age){this->m_Name = name;this->m_Age = age;}string m_Name;int m_Age;
};void test01() {//创建队列queue<Person> q;//准备数据Person p1("唐僧", 30);Person p2("孙悟空", 1000);Person p3("猪八戒", 900);Person p4("沙僧", 800);//向队列中添加元素 入队操作q.push(p1);q.push(p2);q.push(p3);q.push(p4);//队列不提供迭代器,更不支持随机访问 while (!q.empty()) {//输出队头元素cout << "队头元素-- 姓名: " << q.front().m_Name << " 年龄: "<< q.front().m_Age << endl;cout << "队尾元素-- 姓名: " << q.back().m_Name << " 年龄: " << q.back().m_Age << endl;cout << endl;//弹出队头元素q.pop();}cout << "队列大小为:" << q.size() << endl;
}int main() {test01();system("pause");return 0;
}
6、list容器
链表(list):物理存储单元上是非连续的,数据元素的逻辑顺序是通过链表中的指针链接实现的;
链表的组成:链表(list),由一系列结点组成的;
结点的组成:
- 数据域:存储数据元素;
- 指针域:存储下一个结点地址;
STL中的链表(list),是一个双向循环链表;
由于链表(list)的存储方式并不是连续的内存空间,因此链表(list),中的迭代器只支持前移和后移,属于双向迭代器;
(1)list基本概念:
功能:将数据进行链式存储;
- STL中List和vector是两个最常被使用的容器,各有优缺点;
- List有一个重要的性质,插入和删除操作都不会造成原有list迭代器的失效,这在vector容器中是不成立的;
list的优点:相较于,数组(vector)
- 采用动态存储分配,不会造成内存浪费和溢出;
- 可以对任意位置元素,进行快速的插入或删除操作,修改指针即可,不需要移动元素;
list的缺点:相较于,数组(vector)
- 占用的空间比数组(vector)大;
- 容器遍历的速度没有数组(vector)快;
(2)list构造函数:
功能:创建list容器(初始化一个list容器)
函数原型:
list<T> lst;
// 默认构造;list(beg,end);
// 区间构造,将[beg, end)区间中的元素拷贝给本身;list(n,elem);
// 将n个elem拷贝给本身;(n是个数,elem是值)list(const list &lst);
// 拷贝构造;
示例:使用时包含头文件list
#include <list>void printList(const list<int>& L) {for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {cout << *it << " ";}cout << endl;
}void test01()
{// 默认构造list<int>L1;L1.push_back(10);L1.push_back(20);L1.push_back(30);L1.push_back(40);printList(L1);// 区间构造,将[L1.begin(),L1.end())区间中的元素拷贝给本身list<int>L2(L1.begin(),L1.end());printList(L2);// 拷贝构造list<int>L3(L2);printList(L3);// 将n个elem拷贝给本身list<int>L4(10, 1000);printList(L4);
}int main() {test01();system("pause");return 0;
}
(3) list 赋值和交换:
功能:给list容器进行赋值,以及交换list容器
函数原型:
assign(beg, end);
// assign()区间赋值,将[begin, end)区间中的数据,赋值给本身;assign(n, elem);
// assign()赋值,将n个elem赋值给本身;(n是个数,elem是值)list& operator=(const list &lst);
// 等号赋值;swap(lst);
// 将lst与本身的元素互换;
示例:使用时包含头文件list
#include <list>void printList(const list<int>& L) {for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {cout << *it << " ";}cout << endl;
}//赋值
void test01()
{list<int>L1;L1.push_back(10);L1.push_back(20);L1.push_back(30);L1.push_back(40);printList(L1);// 等号赋值list<int>L2;L2 = L1;printList(L2);// assign()区间赋值list<int>L3;L3.assign(L2.begin(), L2.end());printList(L3);// assign()赋值,将n个elem赋值给本身list<int>L4;L4.assign(10, 100);printList(L4);}// swap(lst)交换
void test02()
{list<int>L1;L1.push_back(10);L1.push_back(20);L1.push_back(30);L1.push_back(40);list<int>L2;L2.assign(10, 100);cout << "交换前: " << endl;printList(L1);printList(L2);cout << endl;L1.swap(L2);cout << "交换后: " << endl;printList(L1);printList(L2);}int main() {//test01();test02();system("pause");return 0;
}
(4) list 大小操作:
功能:对list容器的大小进行操作
函数原型:
empty();
// 判断容器是否为空;size();
// 返回容器中元素的个数;resize(num);
// 重新指定容器的长度为num(若容器变长则以默认值填充新位置,如果容器变短则末尾超出容器长度的元素被删除);resize(num, elem);
// 重新指定容器的长度为num(若容器变长则以elem值填充新位置,如果容器变短则末尾超出容器长度的元素被删除);
示例:使用时包含头文件list
#include <list>void printList(const list<int>& L) {for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {cout << *it << " ";}cout << endl;
}//大小操作
void test01()
{list<int>L1;L1.push_back(10);L1.push_back(20);L1.push_back(30);L1.push_back(40);// 1、判断是否为空if (L1.empty()){cout << "L1为空" << endl;}else{cout << "L1不为空" << endl;// 2、返回元素个数cout << "L1的大小为: " << L1.size() << endl;}// 3、重新指定容器的长度L1.resize(10);printList(L1);L1.resize(2);printList(L1);
}int main() {test01();system("pause");return 0;
}
(5) list 插入和删除:
功能:对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
#include <list>void printList(const list<int>& L) {for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {cout << *it << " ";}cout << endl;
}//插入和删除
void test01()
{list<int> L;//尾插L.push_back(10);L.push_back(20);L.push_back(30);//头插L.push_front(100);L.push_front(200);L.push_front(300);printList(L);//尾删L.pop_back();printList(L);//头删L.pop_front();printList(L);//插入list<int>::iterator it = L.begin();L.insert(++it, 1000);printList(L);//删除it = L.begin();L.erase(++it);printList(L);//移除L.push_back(10000);L.push_back(10000);L.push_back(10000);printList(L);L.remove(10000);printList(L);//清空L.clear();printList(L);
}int main() {test01();system("pause");return 0;
}
(6) list 数据存取:
功能:对list容器中数据进行存取
函数原型:
front();
// 返回第一个元素back();
// 返回最后一个元素
示例:使用时包含头文件list
#include <list>//数据存取
void test01()
{list<int>L1;L1.push_back(10);L1.push_back(20);L1.push_back(30);L1.push_back(40);// list容器中不可以通过[]或者at方式访问数据// cout << L1.at(0) << endl; // 错误 不支持 at 访问数据// cout << L1[0] << endl; // 错误 不支持 [] 访问数据cout << "第一个元素为: " << L1.front() << endl;cout << "最后一个元素为: " << L1.back() << endl;//list容器的迭代器是双向迭代器,不支持随机访问list<int>::iterator it = L1.begin();//it = it + 1;//错误,不可以跳跃访问,即使是+1
}int main() {test01();system("pause");return 0;
}
(7)list 反转和排序:
功能:将容器中的元素反转,以及将容器中的数据进行排序
函数原型:
reverse();
// 反转链表sort();
// 链表排序
示例:使用时包含头文件list
void printList(const list<int>& L) {for (list<int>::const_iterator it = L.begin(); it != L.end(); it++) {cout << *it << " ";}cout << endl;
}bool myCompare(int val1 , int val2)
{return val1 > val2;
}void test01()
{list<int> L;L.push_back(90);L.push_back(30);L.push_back(20);L.push_back(70);printList(L);//反转容器的元素L.reverse();printList(L);
// 所有不支持随机访问迭代器的容器,都不可以用标准算法(algorithm)里提供的的全局函数
// 不支持随机访问迭代器的容器,内部会提供对应的一些算法,这里使用的sort()函数,是list容器内部的成员函数L.sort(); // 默认的排序规则 从小到大printList(L);L.sort(myCompare); //指定规则,从大到小printList(L);
}int main() {test01();system("pause");return 0;
}
7、set/ multiset 容器,(也叫,set集合)
(1)set 基本概念
简介:
- 所有元素在插入时都会被自动排序;
- set/multiset属于关联式容器,底层结构是用二叉树实现的;
set和multiset区别:
- set不允许容器中有重复的元素(set不可以插入重复数据);
- multiset允许容器中有重复的元素(multiset可以插入重复数据);
(2) set构造和赋值:
功能:
创建set容器
赋值
函数原型:
构造:
set<T> st;
// 默认构造set(const set &st);
// 拷贝构造
赋值:
set& operator=(const set &st);
// 等号赋值
示例:使用时包含头文件set
#include <set>void printSet(set<int> & s)
{for (set<int>::iterator it = s.begin(); it != s.end(); it++){cout << *it << " ";}cout << endl;
}//构造和赋值
void test01()
{set<int> s1;// set容器插入数据时用insert,插入的数据会自动排序(从小到大)s1.insert(10);s1.insert(30);s1.insert(20);s1.insert(40);printSet(s1);//拷贝构造set<int>s2(s1);printSet(s2);//赋值set<int>s3;s3 = s2;printSet(s3);
}int main() {test01();system("pause");return 0;
}
(3) set 大小和交换:
功能:统计set容器大小以及交换set容器
函数原型:
size();
// 返回容器中元素的个数empty();
// 判断容器是否为空swap(st);
// 交换两个set集合
示例:使用时包含头文件 set
#include <set>void printSet(set<int> & s)
{for (set<int>::iterator it = s.begin(); it != s.end(); it++){cout << *it << " ";}cout << endl;
}//大小
void test01()
{set<int> s1;s1.insert(10);s1.insert(30);s1.insert(20);s1.insert(40);if (s1.empty()){cout << "s1为空" << endl;}else{cout << "s1不为空" << endl;cout << "s1的大小为: " << s1.size() << endl;}}//交换
void test02()
{set<int> s1;s1.insert(10);s1.insert(30);s1.insert(20);s1.insert(40);set<int> s2;s2.insert(100);s2.insert(300);s2.insert(200);s2.insert(400);cout << "交换前" << endl;printSet(s1);printSet(s2);cout << endl;cout << "交换后" << endl;s1.swap(s2);printSet(s1);printSet(s2);
}int main() {//test01();test02();system("pause");return 0;
}
(4) set 插入和删除:
功能:set容器进行插入数据和删除数据
函数原型:
insert(elem);
// 在容器中插入元素。clear();
// 清空所有元素erase(pos)
// 删除pos迭代器所指的元素,返回下一个元素的迭代器erase(beg,end)
// 删除区间[beg,end)的所有元素,返回下一个元素的迭代器- `erase(elem); // 删除容器中值为elem的元素
示例:使用时包含头文件set
#include <set>void printSet(set<int> & s)
{for (set<int>::iterator it = s.begin(); it != s.end(); it++){cout << *it << " ";}cout << endl;
}//插入和删除
void test01()
{set<int> s1;//插入s1.insert(10);s1.insert(30);s1.insert(20);s1.insert(40);printSet(s1);//删除s1.erase(s1.begin());printSet(s1);s1.erase(30);printSet(s1);//清空//s1.erase(s1.begin(), s1.end());s1.clear();printSet(s1);
}int main() {test01();system("pause");return 0;
}
(5) set查找和统计:
功能:对set容器进行查找数据以及统计数据
函数原型:
find(value);
// 查找值等于value的元素是否存在(若存在则返回该键的元素的迭代器;若不存在则返回set.end())count(value);
// 统计set中,值等于value的元素个数
示例:使用时包含头文件list
#include <set>//查找和统计
void test01()
{set<int> s1;//插入s1.insert(10);s1.insert(30);s1.insert(20);s1.insert(40);//查找set<int>::iterator pos = s1.find(30);// 查找值等于30的元素是否存在if (pos != s1.end()){cout << "找到了元素 : " << *pos << endl;}else{cout << "未找到元素" << endl;}//统计值等于30的个数int num = s1.count(30);cout << "num = " << num << endl;
}int main() {test01();system("pause");return 0;
}
(6)pair 对组
功能描述:
- 成对出现的一组数据,利用对组可以返回两个数据
两种创建方式:
pair<type, type> p ( value1, value2 )
pair<type, type> p = make_pair( value1, value2 )
示例:不需要包含头文件
#include <string>//对组创建
void test01()
{// pair<type, type> p ( value1, value2 ) 方式pair<string, int> p(string("Tom"), 20);cout << "姓名: " << p.first << " 年龄: " << p.second << endl;// pair<type, type> p = make_pair( value1, value2 ) 方式pair<string, int> p2 = make_pair("Jerry", 10);cout << "姓名: " << p2.first << " 年龄: " << p2.second << endl;
}int main() {test01();system("pause");return 0;
}
(7) set容器排序:
学习目标:set容器默认排序规则为从小到大,掌握如何改变排序规则
主要技术点:
- 利用仿函数,可以改变排序规则
- 对于自定义数据类型,set必须指定排序规则才可以插入数据;
示例一:set存放内置数据类型
#include <set>// 利用仿函数可以指定set容器的排序规则
class MyCompare
{public:bool operator()(int v1, int v2) {return v1 > v2;}
};
void test01()
{ set<int> s1;s1.insert(10);s1.insert(40);s1.insert(20);s1.insert(30);s1.insert(50);//默认从小到大for (set<int>::iterator it = s1.begin(); it != s1.end(); it++) {cout << *it << " ";}cout << endl;//指定排序规则set<int,MyCompare> s2;s2.insert(10);s2.insert(40);s2.insert(20);s2.insert(30);s2.insert(50);for (set<int, MyCompare>::iterator it = s2.begin(); it != s2.end(); it++) {cout << *it << " ";}cout << endl;
}int main() {test01();system("pause");return 0;
}
示例二:set存放自定义数据类型,set 必须指定排序规则才可以插入数据;
#include <set>
#include <string>class Person
{public:Person(string name, int age){this->m_Name = name;this->m_Age = age;}string m_Name;int m_Age;};
// 对于自定义数据类型,set必须指定排序规则才可以插入数据
class comparePerson
{public:bool operator()(const Person& p1, const Person &p2){//按照年龄进行排序 降序return p1.m_Age > p2.m_Age;}
};void test01()
{set<Person, comparePerson> s;Person p1("刘备", 23);Person p2("关羽", 27);Person p3("张飞", 25);Person p4("赵云", 21);s.insert(p1);s.insert(p2);s.insert(p3);s.insert(p4);for (set<Person, comparePerson>::iterator it = s.begin(); it != s.end(); it++){cout << "姓名: " << it->m_Name << " 年龄: " << it->m_Age << endl;}
}
int main() {test01();system("pause");return 0;
}
8、map/ multimap容器(也叫,map集合)
(1)map 基本概念
简介:
- map中所有元素都是pair,pair中第一个元素为key(键),第二个元素为value(值);
- map中所有元素都是成对出现,插入数据时候要使用对组;
- map/multimap属于关联式容器,底层结构是用二叉树实现;
优点
- 可以根据key快速找到value值;
map和multimap区别:
- map不允许容器中有重复的key(set不可以插入重复的key);
- multimap允许容器中有重复的key(multiset可以插入重复的key);
(2) map构造和赋值:
功能:
创建map容器
赋值
函数原型:
构造:
- map<T1, T2> mp; // 默认构造
- map(const map &mp); // 拷贝构造
赋值:
- map& operator=(const map &mp) // 等号赋值
示例:使用时包含头文件map
#include <map>void printMap(map<int,int>&m)
{for (map<int, int>::iterator it = m.begin(); it != m.end(); it++){cout << "key = " << it->first << " value = " << it->second << endl;}cout << endl;
}void test01()
{// map中所有元素都是成对出现,插入数据时候要使用对组map<int,int>m; //默认构造m.insert(pair<int, int>(1, 10));m.insert(pair<int, int>(2, 20));m.insert(pair<int, int>(3, 30));printMap(m);map<int, int>m2(m); //拷贝构造printMap(m2);map<int, int>m3;m3 = m2; //赋值printMap(m3);
}int main() {test01();system("pause");return 0;
}
(3) map大小和交换:
功能:统计map容器大小以及交换map容器
函数原型:
size();
// 返回容器中元素的个数empty();
// 判断容器是否为空swap(st);
// 交换两个map集合
示例:使用时包含头文件map
#include <map>void printMap(map<int,int>&m)
{for (map<int, int>::iterator it = m.begin(); it != m.end(); it++){cout << "key = " << it->first << " value = " << it->second << endl;}cout << endl;
}void test01()
{map<int, int>m;m.insert(pair<int, int>(1, 10));m.insert(pair<int, int>(2, 20));m.insert(pair<int, int>(3, 30));if (m.empty()){cout << "m为空" << endl;}else{cout << "m不为空" << endl;cout << "m的大小为: " << m.size() << endl;}
}//交换
void test02()
{map<int, int>m;m.insert(pair<int, int>(1, 10));m.insert(pair<int, int>(2, 20));m.insert(pair<int, int>(3, 30));map<int, int>m2;m2.insert(pair<int, int>(4, 100));m2.insert(pair<int, int>(5, 200));m2.insert(pair<int, int>(6, 300));cout << "交换前" << endl;printMap(m);printMap(m2);cout << "交换后" << endl;m.swap(m2);printMap(m);printMap(m2);
}int main() {test01();test02();system("pause");return 0;
}
(4) map插入和删除:
功能:map容器进行插入数据和删除数据
函数原型:
insert(elem)
// 在容器中插入元素;clear()
// 清除所有元素;erase(pos)
// 删除pos迭代器所指的元素,返回下一个元素的迭代器;erase(beg, end)
// 删除区间[beg, end)的所有元素,返回下一个元素的迭代器;erase(value)
// 删除容器中值为value的元素;
示例:使用时包含头文件map
#include <map>void printMap(map<int,int>&m)
{for (map<int, int>::iterator it = m.begin(); it != m.end(); it++){cout << "key = " << it->first << " value = " << it->second << endl;}cout << endl;
}void test01()
{//插入map<int, int> m;//第一种插入方式m.insert(pair<int, int>(1, 10));//第二种插入方式m.insert(make_pair(2, 20));//第三种插入方式m.insert(map<int, int>::value_type(3, 30));//第四种插入方式m[4] = 40; printMap(m);//删除m.erase(m.begin());printMap(m);m.erase(3);printMap(m);//清空m.erase(m.begin(),m.end());m.clear();printMap(m);
}int main() {test01();system("pause");return 0;
}
(5) map查找和统计:
功能:对map容器进行查找数据以及统计数据
函数原型:
find(key);
// 查找键等于key的元素是否存在(若存在则返回该键的元素的迭代器;若不存在则返回set.end())count(key);
// 统计键等于key的元素个数
示例:使用时包含头文件map
#include <map>//查找和统计
void test01()
{map<int, int>m; m.insert(pair<int, int>(1, 10));m.insert(pair<int, int>(2, 20));m.insert(pair<int, int>(3, 30));// 查找键key=3的元素是否存在map<int, int>::iterator pos = m.find(3);if (pos != m.end()){cout << "找到了元素 key = " << (*pos).first << " value = " << (*pos).second << endl;}else{cout << "未找到元素" << endl;}// 统计键key=3的元素个数int num = m.count(3);cout << "num = " << num << endl;
}int main() {test01();system("pause");return 0;
}
(6) map容器排序:
功能:map容器默认排序规则为 按照key值进行 从小到大排序,掌握如何改变排序规则
主要技术点:
利用仿函数,可以改变排序规则;
对于自定义数据类型,map必须指定排序规则才可以插入数据;
示例:使用时包含头文件map
#include <map>class MyCompare {public:bool operator()(int v1, int v2) {return v1 > v2;}
};void test01()
{//默认从小到大排序//利用仿函数实现从大到小排序map<int, int, MyCompare> m;m.insert(make_pair(1, 10));m.insert(make_pair(2, 20));m.insert(make_pair(3, 30));m.insert(make_pair(4, 40));m.insert(make_pair(5, 50));for (map<int, int, MyCompare>::iterator it = m.begin(); it != m.end(); it++) {cout << "key:" << it->first << " value:" << it->second << endl;}
}
int main() {test01();system("pause");return 0;
}
C++提高编程----STL标准模板库-常用容器相关推荐
- 19.3 C++STL标准模板库大局观-容器的说明和简单应用例续
19.1 C++STL标准模板库大局观-STL总述.发展史.组成与数据结构谈 19.2 C++STL标准模板库大局观-容器分类与array.vector容器精解 19.3 C++STL标准模板库大局观 ...
- 补8-5日复习内容 STL 标准模板库的容器
//有关 STL 标准模板库的函数 /* string 的 */ /* #include <iostream> #include <string> #include <w ...
- c++学习笔记-提高篇-STL标准模板库2(哔站-黑马程序员c++教学视频)
STL常用容器:string.vector.deque 目录 STL常用容器:string.vector.deque 一.string容器 1.string的基本概念 2.string的构造函数 3. ...
- 19.1 C++STL标准模板库大局观-STL总述、发展史、组成与数据结构谈
19.1 C++STL标准模板库大局观-STL总述.发展史.组成与数据结构谈 19.2 C++STL标准模板库大局观-容器分类与array.vector容器精解 19.3 C++STL标准模板库大局观 ...
- stl标准模板库_C ++标准模板库(STL)中的数组及其常用功能
stl标准模板库 "array" is a container in C++ STL, which has fixed size, which is defined in &quo ...
- 信息学奥赛中的STL(标准模板库)--2022.09.30
1.信息学奥赛一本通 第5版 第8章 C++实用技巧与模版库(6节) 第一节 排序算法 第二节 运算符重载 第三节 字符串(string) 第四节 FIFO队列和优先队列 第五节 动态数组 第六 ...
- C++ STL 标准模板库介绍与入门
目录 1.概述 1.1.C++ 标准库 1.2.Boost库 2.STL 版本 2.1.HP 原始版本 2.2.P. J. 实现版本 2.3.RW 实现版本 2.4.SGI 实现版本 2.5.STLp ...
- C++入门到精通 ——第七章 STL标准模板库大局观
七.STL标准模板库大局观 Author: XFFer_ 先分享一本 <C++ 标准库 第二版> ,望在STL的道路上从入门到放弃!(开玩笑的啦,愈行愈远~) 链接: https://pa ...
- STL(标准模板库)理论基础与容器
10.1 STL(标准模板库)理论基础 10.1.1基本概念 STL(Standard Template Library,标准模板库)是惠普实验室开发的一系列软件的统称.现然主要出现在C++中,但在被 ...
最新文章
- 顺序表应用8:最大子段和之动态规划法
- webpack 初体验
- 用CSS美化被鼠标选中的文字的样式
- 了解单片机及单片机的控制原理和 DX516 的用法,控制一个 LED 灯的亮
- [转贴]犯贱报(一张浓缩大学生活的..)
- 红包指定分配金额php,php仿微信红包分配算法的实现方法_PHP
- Angular.js学习-入门
- rsync的介绍及参数详解,配置步骤,工作模式介绍
- 微软算法面试题(4)
- iOS pickerView(所有类型一网打尽)
- 力扣题目——29. 两数相除
- ASCII对应码表(键值)
- 微信小程序自定义拍照和H5调用摄像头拍照
- 修改Ceph 监视器地址
- Python 【趣头条】短视频的自动上传与发布实例演示,同时支持抖音、快手、哔哩哔哩、小红书、微视、西瓜视频、微信视频号等平台的视频自动化同步发布
- Hazelcast IMDG参考中文版手册-第十一章-分布式查询
- 3dmax su 简单_【建模技巧】如何用3DMAX制作简单的绣球模型
- 编解码(1)之基本像素格式转换
- KMP算法及next数组(最大公共前后缀)求解
- 一些多元逐步回归的注意事项
热门文章
- .env.development(开发环境)、.env.prodction(正式环境)、自定义环境的使用
- MFC 消息中( WPARAM wParam,LPARAM lParam)包含信息
- 数据格式转换(二)纯文本抽出
- 质量保证与质量控制的区别
- 电力网络安全区域概念及划分
- 豪杰春香,韩剧《豪杰春香》《豪杰春香》在线播放地址
- 程序人生 - 在德国,炒房是要坐牢的
- BUUCTF·[MRCTF2020]babyRSA·WP
- 标定学习笔记(三)-- 利用OpenCV实现张正友标定法
- 安装sql2005及SQL2000和SQL2005共存问题