文章目录
STL的诞生
- 长久以来, 软件界一直希望建立一种可重复利用的东西
- C++的面向对象和泛型编程的思想, 目的就是服用性的提升
- 封装 : 把属性和行为相似的对象抽象成一个类, 把属性和行为封装成一个整体描述这种类型
- 继承 : 子类继承父类的属性和行为
- 多态 : 一个函数名称多个接口, 根据对象不同,调用不同的行为
- 大多情况下, 数据结构和算法未能有一套标准, 导致被迫重复大量工作.
- 为了建立数据结构和算法的一套标准, 诞生了STL
STL的基本概念
- STL : Standard Template Library 标准模板库
- STL从广义上分为 : 容器(container) 算法(algorithm) 迭代器(iterator)
- 容器和算法之间通过迭代器无缝连接
- STL几乎所有代码都包含了模板类和模板函数
STL六大组件
- 容器, 算法, 迭代器, 仿函数, 适配器, 空间配置器
- 容器 : 各种数据结构, 如vector, list, queue, set, map, 用来存放数据
- 算法 : 各种常用的算法, 如sort, find, copy, for_each
- 迭代器 : 容器和算法之间的胶合剂
- 仿函数 : 行为类似函数, 可以作为算法的某种策略
- 适配器 : 一种用来修饰容器或者仿函数或者迭代器接口的东西
- 空间配置器 : 负责空间的配置和管理
容器
- 序列式容器 和 关联式容器
- 序列式容器 : 强调值的排序, 序列式容器中每个元素都有固定位置
- 关联式容器 : 二叉树结构, 各元素之间没有严格的物理上的顺序.
算法
- 质变算法 和 非质变算法
- 质变算法 : 运算过程中会更改区间内的元素内容, 如拷贝, 替换, 删除
- 非质变算法 : 运算过程中不会更改区间内的元素内容, 如查找, 计数, 遍历, 寻找极值.
迭代器
-
容器用来提供数据, 算法用来解决问题. 而算法需要通过迭代器才能访问到容器中的数据
-
每个容器都有自己专属的迭代器
-
迭代器的使用非常类似指针
-
迭代器的种类
- 输入迭代器 : 对数据只读访问
- 输出迭代器 : 对数据只写访问
- 前向迭代器 : 读写操作, 并能向前推进迭代器
- 双向迭代器 : 读写操作, 并能向前和向后操作
- 随机访问迭代器 : 读写操作, 可以跳跃的方式访问任意数据, 功能最强的迭代器
-
常用容器中的迭代器种类为双向迭代器 和 随机访问迭代器
vector容器存放内置数据类型
void printV(int val)
{
cout<<val<<endl;
}
void test02()
{
// 创建容器对象, 通过模板参数确定容器中存放的数据类型
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 itBegin = v.begin();
vector<int>::iterator itEnd = v.end();
// 第一种遍历方式
while(itBegin != itEnd)
{
cout<<*itBegin<<endl;
itBegin++;
}
cout<<endl;
// 第二种遍历方式
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
{
cout<<*it<<endl;
}
cout<<endl;
// 第三种遍历方式, 第三个参数是一个函数名, 会传入一个*iterator参数
for_each(v.begin(), v.end(), printV);
}
vector容器存放自定义数据类型
- . 运算符比 * 运算法优先级高, 所以要加()
class Person
{
public:
Person(string name, int age) : m_age(age), m_name(name){}
int m_age;
string m_name;
};
void test03()
{
vector<Person> v;
Person p1("y", 10);
Person p2("yy", 20);
Person p3("yyy", 30);
Person p4("yyyy", 40);
Person p5("yyyyy", 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->m_name<<" age : "<<it->m_age<<endl;
cout<<"name : "<<(*it).m_name<<" age : "<<(*it).m_age<<endl;
}
}
void test04()
{
vector<Person*> v;
Person p1("y", 10);
Person p2("yy", 20);
Person p3("yyy", 30);
Person p4("yyyy", 40);
Person p5("yyyyy", 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)->m_name<<" age : "<<(*it)->m_age<<endl;
cout<<"name : "<<(*(*it)).m_name<<" age : "<<(*(*it)).m_age<<endl;
}
}
容器嵌套容器
- *it 查看<>中的内容即可, <>里是什么, *it就是什么
void test05()
{
vector<vector<int>> v;
vector<int> v1;
vector<int> v2;
vector<int> v3;
vector<int> v4;
for(int i = 0; i < 4; i++)
{
v1.push_back(i + 1);
v2.push_back(i + 2);
v3.push_back(i + 3);
v4.push_back(i + 4);
}
v.push_back(v1);
v.push_back(v2);
v.push_back(v3);
v.push_back(v4);
// 遍历大容器
for(vector<vector<int>>::iterator it1 = v.begin(); it1 != v.end(); it1++)
{
// 遍历小容器
for(vector<int>::iterator it2 = (*it1).begin(); it2 != (*it1).end(); it2++)
{
cout<<*it2<<" ";
}
cout<<endl;
}
}
string
- 本质
- C++风格的字符串, 本质是一个类
- string 和 char* 的区别
- char* 是一个指针
- string 是一个类, 封装了char*, 管理这个字符串, 是一个char*的容器
- 特点
- string 内部封装了很多成员方法, 例如find, copy, replace, insert
- string管理char*分配的内存, 不用担心越界问题, 由类内不负责处理
构造函数
- string() // 创建一个空字符串, 比如 string str;
- string (const char*) // 使用字符串s初始化
- string(const string& str) // 使用一个string对象初始化另一个string对象
- string(int n, char c) // 使用n个字符c初始化
void test06()
{
string s1;
const char* str = "hello world";
string s2(str);
cout<<"s2 = "<<s2<<endl;
string s3(s2);
cout<<"s3 = "<<s3<<endl;
string s4(3, 'y');
cout<<"s4 = "<<s4<<endl;
}
string 赋值操作
- string字符串, c字符串, 字符
- string, const char*, char
string字符串拼接
- const char* 和 string 是一样的
- string& append(char * s, int n); 把s的前n个字符拼接到字符串结尾
- string& append(const string& s, int pos, int n); 字符串s从pos开始的n个字符拼接到字符串结尾
字符串查找和替换
- find 从左往右, rfind从右往左(最后一个字符串)
- find找不到返回 -1
- replace(起始位置, 多少个, 替换字符串);
字符串比较
- 字符串比较主要是比较是否相等, 比较大小意义不大.
字符串存取
string插入和删除
string子串
- 从哪个位置起, 截取多少个 (第二个参数是个数, 而不是末位置)
vector容器
- vector和数组非常相似, 称为单端数组
- 不同之处在于, 数组是静态的, vector是动态扩展的
- 动态扩展 : 不是在原空间续新空间, 而是找更大的空间, 然后将原数据拷贝到新空间, 释放原空间.
vector构造函数
- 默认构造函数是一个空vector
void test08()
{
vector<int> v1; // 默认构造, 空vector
for(int i = 0; i < 10; i++)
{
v1.push_back(i);
}
// 将一个区间中的元素拷贝构造
vector<int> v2(v1.begin(), v1.end());
// 将n个element拷贝构造
vector<int> v3(5, 10);
// 拷贝构造
vector<int> v4(v3);
printVector(v4);
}
vector 赋值操作
- 先利用默认构造函数创建一个空容器, 然后进行赋值
vector的容量和大小
- 重新指定容器长度是指元素个数改变, 默认填充的是0, 容量并没有变;
- 是否为空指的也是元素个数.
void test09()
{
vector<int> v;
for(int i = 0; i < 10; i++)
{
v.push_back(i);
}
cout<<"是否为空: "<<v.empty()<<endl;
cout<<"元素个数: "<<v.size()<<endl;
cout<<"容器大小: "<<v.capacity()<<endl;
printVector(v);
v.resize(20, 2);
cout<<"是否为空: "<<v.empty()<<endl;
cout<<"元素个数: "<<v.size()<<endl;
cout<<"容器大小: "<<v.capacity()<<endl;
printVector(v);
v.resize(5);
cout<<"是否为空: "<<v.empty()<<endl;
cout<<"元素个数: "<<v.size()<<endl;
cout<<"容器大小: "<<v.capacity()<<endl;
printVector(v);
}
vector插入和删除
- 删除的时候容量并不会跟着缩小
- 只有插入的时候, 如果超过了容量, 才会需找更大的容量, 拷贝过去.
void test10()
{
vector<int> v;
for(int i = 0; i < 10; i++)
{
v.push_back(i);
}
printVector(v);
v.push_back(11);
v.push_back(12);
v.push_back(13);
v.pop_back();
printVector(v);
v.insert(v.begin(), 100); // 位置是一个迭代器
printVector(v);
cout<<"是否为空: "<<v.empty()<<endl;
cout<<"元素个数: "<<v.size()<<endl;
cout<<"容器大小: "<<v.capacity()<<endl;
v.insert(v.begin(), 3, 1000);
printVector(v);
v.erase(v.begin());
printVector(v);
v.erase(v.begin(), v.end()); // 位置也是一个迭代器
printVector(v);
cout<<"是否为空: "<<v.empty()<<endl;
cout<<"元素个数: "<<v.size()<<endl;
cout<<"容器大小: "<<v.capacity()<<endl;
}
vector数据存取
void test11()
{
vector<int> v;
for(int i = 0; i < 10; i++)
{
v.push_back(i);
}
printVector(v);
cout<<v.front()<<endl;
cout<<v.back()<<endl;
cout<<v[3]<<endl;
cout<<v.at(2)<<endl;
}
vector 互换容器
- 容器互换, 不仅是元素互换, 容量也互换, 所有都互换了 (指针交换)
- 用来收缩内存
vector<int> v3(10000, 1);
cout<<v3.size()<<endl;
cout<<v3.capacity()<<endl;
v3.resize(3);
cout<<v3.size()<<endl;
cout<<v3.capacity()<<endl;
vector<int>(v3).swap(v3);
cout<<v3.size()<<endl;
cout<<v3.capacity()<<endl;
- vector(v3) 利用拷贝构造函数, 创建了一个匿名对象, 这个匿名对象的大小和容量都是3, 然后和原来的v3进行指针互换, 匿名对象调用完后立即释放, 因此原来占据的10000的空间也自动被系统释放.
vector预留空间
- 只是分配了内存, 内存上并未初始化, 也不可访问.
void test13()
{
vector<int> v;
v.reserve(100000); // 19->1
int num = 0;
int *p = NULL;
for(int i = 0; i < 100000; i++)
{
v.push_back(i);
if(p != &v[0])
{
p = &v[0];
num++;
}
}
cout<<num<<endl;
}
deque 容器
- 双端数组, 两端都可以进行插入和删除
- deque和vector的区别
- vector对头部的插入删除效率较低, 数据量越大, 效率越低
- deque对头部的插入删除相较于vector速度较快
- vector访问元素的速度比deque快, 这和他们的内部实现有关
内部工作原理
deque构造函数
-
和vector类似
-
如果想让容器中的元素只读, 相应的迭代器也要修改成const_iterator
void printDeque(const deque<int>& d)
{
for(deque<int>::const_iterator it = d.begin(); it != d.end(); it++)
{
// *it = 100; 只读传入, 不能修改deque内容, 迭代器也要相应更改
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(d1.begin(), d1.end());
printDeque(d2);
deque<int> d3(4, 100);
printDeque(d3);
deque<int> d4(d3);
printDeque(d4);
}
deque赋值操作
- = , 区间, n个元素, 和vector相同
deque大小操作
- 没有容量, 因为内部实现和vector不同, 他只需要一个中空气, 容量不限制
deque插入和删除
deque数据存取
deque排序