STL总结

Never-SayNever

已于 2023-05-15 22:37:28 修改

阅读量175

点赞数

分类专栏： c++ 文章标签：开发语言

于 2022-03-18 23:40:39 首次发布

本文链接：https://blog.csdn.net/t567g123/article/details/123587109

版权

c++ 专栏收录该内容

37 篇文章 1 订阅

订阅专栏

string

定义说明

std::string实际上是basic_string的一个特化,即:

typedef basic_string<char> string;

所以,std::string继承了basic_string的全部接口和实现,只是进一步将char定义为默认模板参数,方便使用。

basic_string是std::string真正的实现基础。它是一个类模板,依赖三个模板参数:

charT:字符类型,std::string特化为char。
traits:字符特性,默认为char_traits。
Allocator:字符分配器,默认为allocator。
基于这三个模板参数,basic_string定制了一个通用的字符串类,可以表示和操作不同字符类型的数据。无论charT是char,wchar_t还是其他,basic_string都适用。这体现了C++模板带来的优势—通用性和可重用性。
所以,理解std::string需要理解basic_string,需要理解:
什么是模板和模板参数,如何产生模板类实例。
char_traits和allocator的作用,以及它们如何依赖模板参数。
basic_string的实现机制,如存储结构、内存分配、字符操作等。
std::string仅仅是基于char的一个特化,其他字符类型同样可以使用basic_string。

string定义在头文件中,而不是或其他STL头文件。这也是一个判断string不是STL组件的参考因素。

而string仅仅是一个用于字符串存储和操作的类,它:

不属于STL容器,虽然提供类似接口但实现不同。
没有迭代器,不能直接使用STL算法。需要转换为char*才能使用。
没有函数对象或配接器。
使用标准的char_traits和allocator,而非STL分配器。

string定义在头文件中,独立于STL相关的头文件。这表明:

string的历史可能更长,早于STL成形。C++自初版起就包含string。
string的目标是文本处理,而非STL的通用工具目的。它解决了一个具体问题。
string的实现机制不同于STL,并不依赖STL的核心组件。它是独立实现的。
string的设计者可能并非出自STL的设计者之手,有不同的考量因素。
所以,理解STL不应将string误认为其组成部分。尽管string提供了和STL相近的接口,但它应被视为标准库的一员,而非STL。

STL

STL（Standard Template Library)，即标准模板库,被容纳于C++标准程序库（C++ Standard Library)中，该库包含了诸多在计算机科学领域里所常用的基本数据结构和基本算法。

STL主要组件和所在头文件如下:

容器:vector(),list(),set(),map()等。用来存放数据。
算法:头文件,如sort、find、copy等。用于操作容器中的数据。
迭代器:头文件,如vector::iterator等。提供统一的接口访问容器中元素。平衡算法与容器
仿函数:头文件,如greater等。可作为算法的比较函数。可作为算法的实参
配接器:,头文件,如priority_queue等。改变容器接口。提供更强功能。如stack/queue等。
分配器:头文件,如allocator。管理内存分配自定义内存分配策略。

STL具有以下主要优点:

高性能:使用模板和内联函数,有良好的缓存命中率和代码优化。
通用:算法和容器分离,可以作用于不同的容器。
便利:提供常用的数据结构和算法,减少重复性代码。
可扩展:通过策略设计,可以定制与扩展。如自定义allocator。
但是,STL也存在一定缺点:
学习曲线陡峭:API比较复杂,涉及许多模板知识,难以理解和掌握。
编译时间长:使用大量模板,编译期生成代码,编译时间显著增加。
可读性差:代码晦涩难懂,不便于调试和理解。
二进制兼容性:不同标准库或编译器的STL兼容性较差。

STL的六大组件

容器（Container)，是一种数据结构，以模板类的方法提供。为了访问容器中的数据，可以使用由容器类输出的迭代器；
- 序列容器：每个元素都有固定位置，取决于插入时机和地点，和元素值无关。
  - vector：
    - vector是基于动态数组，内存空间是连续的，因此支持下标访问。
      定义说明
  - list：
    - 基于双向链表，内存是不连续的，不支持下标访问，支持指针访问。
      定义说明
  - deque ：
    - Deque支持随机访问和存取，支持下标访问，插入删除的效率也很高。是由一段一段定量的连续空间组成的。实现：map+buffer
      [定义说明](https://zh.cppreference.com/w/cpp/container/deque
- 关联容器：元素位置取决于特定的排序准则，和插入顺序无关
  - set/multiset
    - 内部的元素依据其值自动排序，Set内的相同数值的元素只能出现一次，Multisets内可包含多个数值相同的元素，内部由二叉树实现（实际上基于红黑树(RB-tree)实现)，便于查找
      定义说明
       定义说明
  - map /multimap
    - Map的元素是成对的键值/实值，内部的元素依据其值自动排序，Map内的相同数值的元素只能出现一次，Multimaps内可包含多个数值相同的元素，内部由二叉树实现（实际上基于红黑树(RB-tree)实现)，便于查找
      定义说明
       定义说明
  - unordered_set/unordered_multiset
    定义说明
     定义说明
  - unordered_map /unordered_multimap
    定义说明
     定义说明
    1. 定义在<unordered_map>和<unordered_set>头文件中,与其他STL容器一致。
    2. 基于哈希表实现,支持快速查找、插入和删除操作。
    3. 提供和map, multimap, set, multiset相似的接口,但底层数据结构不同。
    4. 同样符合容器,迭代器和算法等STL概念要求。可与STL算法一起使用。
  相比map等有序关联容器,unordered_map的主要优点在于:
```
1. 查找、插入和删除的时间复杂度均为O(1),性能更高效。
2. 无需一定的有序性,更灵活。

但也有些劣势:
1. 无序,所以无法进行区间操作如lower_bound等。
2. 存储密度较低,空间利用率稍差。
3. 迭代器是前向迭代器,只支持++操作。
```
迭代器（Iterator)，提供了访问容器中对象的方法。可以使用一对迭代器指定list或vector中的一定范围的对象。迭代器就如同一个指针。事实上，C++的指针也是一种迭代器。但是，迭代器也可以是那些定义了operator*()以及其他类似于指针的操作符地方法的类对象；
定义说明
- iterator、const_iterator、reverse_iterator、const_reverse_iterator
- 只有顺序容器和关联容器支持迭代器遍历

适配器（Adaptor)

STL提供了三个容器适配器：这些适配器都是包装了vector、list、deque中某个顺序容器的包装器。适配器没有提供迭代器，也不能同时插入或删除多个元素

queue:用deque(默认)或list对象创建了一个先进先出容器
定义说明

  queue<T>::push(T x)
  void queue<T>::pop()
  T queue<T>::back()
  T queue<T>::front()
  queue<T>::size_type 
  queue<T>::size()
  bool queue<T>::empty()

 #include <queue>
 queue<int> intDequeQueue;    
 queue<int,list<int>> intListQueue;

priority_queue:用vector(默认)或deque对象创建了一个排序队列,
定义说明
priority_queue

priority_queue<T>::push(T x)
void priority_queue<T>::pop()
T priority_queue<T>::top()
priority_queue<T>::size_type 
priority_queue<T>::size()
bool priority_queue<T>::empty()

带有权值观念，缺省情况下利用max_heap实现。不提供便利功能，也不提供迭代器

ep:

#include<queue>
priority_queue< int, vector<int>, greater<int> >
priority_queue< int, list<int>, greater<int> >
priority_queue<int> p

stack:用vector，deque(默认)或list对象创建了一个先进后出容器
定义说明

  bool stack<T>::empty()                               //判断堆栈是否为空
  void stack<T>::pop()                                 //弹出栈顶数据
  stack<T>::push(T x)                                  //压入一个数据
  stack<T>::size_type stack<T>::size()                 //返回堆栈长度
  T stack<T>::top()                                    //得到栈顶数据

#include <stack>
stack<int> intDequeStack;  
stack<int,vector<int>> intVectorStack;  
stack<int,list<int>> intListStack;

算法（Algorithm)
- 是用来操作容器中的数据的模板函数，函数本身与他们操作的数据的结构和类型无关，因此他们可以在从简单数组到高度复杂容器的任何数据结构上使用；
  定义说明
  - 查找算法(13个)：判断容器中是否包含某个值
    - adjacent_find: 在iterator对标识元素范围内，查找一对相邻重复元素，找到则返回指向这对元素的第一个元素的ForwardIterator。否则返回last。重载版本使用输入的二元操作符代替相等的判断。
    - binary_search: 在有序序列中查找value，找到返回true。重载的版本实用指定的比较函数对象或函数指针来判断相等。
    - count: 利用等于操作符，把标志范围内的元素与输入值比较，返回相等元素个数。
    - count_if: 利用输入的操作符，对标志范围内的元素进行操作，返回结果为true的个数。
    - equal_range: 功能类似equal，返回一对iterator，第一个表示lower_bound，第二个表示upper_bound。
    - find: 利用底层元素的等于操作符，对指定范围内的元素与输入值进行比较。当匹配时，结束搜索，返回该元素的一个InputIterator。
    - find_end: 在指定范围内查找"由输入的另外一对iterator标志的第二个序列"的最后一次出现。找到则返回最后一对的第一个ForwardIterator，否则返回输入的"另外一对"的第一个ForwardIterator。重载版本使用用户输入的操作符代替等于操作。
    - find_first_of: 在指定范围内查找"由输入的另外一对iterator标志的第二个序列"中任意一个元素的第一次出现。重载版本中使用了用户自定义操作符。
    - find_if: 使用输入的函数代替等于操作符执行find。
    - lower_bound: 返回一个ForwardIterator，指向在有序序列范围内的可以插入指定值而不破坏容器顺序的第一个位置。重载函数使用自定义比较操作。
    - upper_bound: 返回一个ForwardIterator，指向在有序序列范围内插入value而不破坏容器顺序的最后一个位置，该位置标志一个大于value的值。重载函数使用自定义比较操作。
    - search: 给出两个范围，返回一个ForwardIterator，查找成功指向第一个范围内第一次出现子序列(第二个范围)的位置，查找失败指向last1。重载版本使用自定义的比较操作。
    - search_n: 在指定范围内查找val出现n次的子序列。重载版本使用自定义的比较操作。
  - 排序和通用算法(14个)：提供元素排序策略
    - inplace_merge: 合并两个有序序列，结果序列覆盖两端范围。重载版本使用输入的操作进行排序。
    - merge: 合并两个有序序列，存放到另一个序列。重载版本使用自定义的比较。
    - nth_element: 将范围内的序列重新排序，使所有小于第n个元素的元素都出现在它前面，而大于它的都出现在后面。重载版本使用自定义的比较操作。
    - partial_sort: 对序列做部分排序，被排序元素个数正好可以被放到范围内。重载版本使用自定义的比较操作。
    - partial_sort_copy: 与partial_sort类似，不过将经过排序的序列复制到另一个容器。
    - partition: 对指定范围内元素重新排序，使用输入的函数，把结果为true的元素放在结果为false的元素之前。
    - random_shuffle: 对指定范围内的元素随机调整次序。重载版本输入一个随机数产生操作。
    - reverse: 将指定范围内元素重新反序排序。
    - reverse_copy: 与reverse类似，不过将结果写入另一个容器。
    - rotate: 将指定范围内元素移到容器末尾，由middle指向的元素成为容器第一个元素。
    - rotate_copy: 与rotate类似，不过将结果写入另一个容器。
    - sort: 以升序重新排列指定范围内的元素。重载版本使用自定义的比较操作。
    - stable_sort: 与sort类似，不过保留相等元素之间的顺序关系。
    - stable_partition: 与partition类似，不过不保证保留容器中的相对顺序。
  - 删除和替换算法(15个)
    - copy: 复制序列
    - copy_backward: 与copy相同，不过元素是以相反顺序被拷贝。
    - iter_swap: 交换两个ForwardIterator的值。
    - remove: 删除指定范围内所有等于指定元素的元素。注意，该函数不是真正删除函数。内置函数不适合使用remove和remove_if函数。
    - remove_copy: 将所有不匹配元素复制到一个制定容器，返回OutputIterator指向被拷贝的末元素的下一个位置。
    - remove_if: 删除指定范围内输入操作结果为true的所有元素。
    - remove_copy_if: 将所有不匹配元素拷贝到一个指定容器。
    - replace: 将指定范围内所有等于vold的元素都用vnew代替。
    - replace_copy: 与replace类似，不过将结果写入另一个容器。
    - replace_if: 将指定范围内所有操作结果为true的元素用新值代替。
    - replace_copy_if: 与replace_if，不过将结果写入另一个容器。
    - swap: 交换存储在两个对象中的值。
    - swap_range: 将指定范围内的元素与另一个序列元素值进行交换。
    - unique: 清除序列中重复元素，和remove类似，它也不能真正删除元素。重载版本使用自定义比较操作。
    - unique_copy: 与unique类似，不过把结果输出到另一个容器。
  - 排列组合算法(2个)：提供计算给定集合按一定顺序的所有可能排列组合
    - next_permutation: 取出当前范围内的排列，并重新排序为下一个排列。重载版本使用自定义的比较操作。
    - prev_permutation: 取出指定范围内的序列并将它重新排序为上一个序列。如果不存在上一个序列则返回false。重载版本使用自定义的比较操作。
  - 算术算法(4个)
    - accumulate: iterator对标识的序列段元素之和，加到一个由val指定的初始值上。重载版本不再做加法，而是传进来的二元操作符被应用到元素上。
    - partial_sum: 创建一个新序列，其中每个元素值代表指定范围内该位置前所有元素之和。重载版本使用自定义操作代替加法。
    - inner_product: 对两个序列做内积(对应元素相乘，再求和)并将内积加到一个输入的初始值上。重载版本使用用户定义的操作。
    - adjacent_difference: 创建一个新序列，新序列中每个新值代表当前元素与上一个元素的差。重载版本用指定二元操作计算相邻元素的差。
  - 生成和异变算法(6个)
    - fill: 将输入值赋给标志范围内的所有元素。
    - fill_n: 将输入值赋给first到first+n范围内的所有元素。
    - for_each: 用指定函数依次对指定范围内所有元素进行迭代访问，返回所指定的函数类型。该函数不得修改序列中的元素。
    - generate: 连续调用输入的函数来填充指定的范围。
    - generate_n: 与generate函数类似，填充从指定iterator开始的n个元素。
    - transform: 将输入的操作作用与指定范围内的每个元素，并产生一个新的序列。重载版本将操作作用在一对元素上，另外一个元素来自输入的另外一个序列。结果输出到指定容器。
  - 关系算法(8个)
    - equal: 如果两个序列在标志范围内元素都相等，返回true。重载版本使用输入的操作符代替默认的等于操作符。
    - includes: 判断第一个指定范围内的所有元素是否都被第二个范围包含，使用底层元素的<操作符，成功返回true。重载版本使用用户输入的函数。
    - lexicographical_compare: 比较两个序列。重载版本使用用户自定义比较操作。
    - max: 返回两个元素中较大一个。重载版本使用自定义比较操作。
    - max_element: 返回一个ForwardIterator，指出序列中最大的元素。重载版本使用自定义比较操作。
    - min: 返回两个元素中较小一个。重载版本使用自定义比较操作。
    - min_element: 返回一个ForwardIterator，指出序列中最小的元素。重载版本使用自定义比较操作。
    - mismatch: 并行比较两个序列，指出第一个不匹配的位置，返回一对iterator，标志第一个不匹配元素位置。如果都匹配，返回每个容器的last。重载版本使用自定义的比较操作。
  - 集合算法(4个)
    - set_union: 构造一个有序序列，包含两个序列中所有的不重复元素。重载版本使用自定义的比较操作。
    - set_intersection: 构造一个有序序列，其中元素在两个序列中都存在。重载版本使用自定义的比较操作。
    - set_difference: 构造一个有序序列，该序列仅保留第一个序列中存在的而第二个中不存在的元素。重载版本使用自定义的比较操作。
    - set_symmetric_difference: 构造一个有序序列，该序列取两个序列的对称差集(并集-交集)。
- 堆算法(4个)
  - make_heap: 把指定范围内的元素生成一个堆。重载版本使用自定义比较操作。
  - pop_heap: 并不真正把最大元素从堆中弹出，而是重新排序堆。它把first和last-1交换，然后重新生成一个堆。可使用容器的back来访问被"弹出"的元素或者使用pop_back进行真正的删除。重载版本使用自定义的比较操作。
  - push_heap: 假设first到last-1是一个有效堆，要被加入到堆的元素存放在位置last-1，重新生成堆。在指向该函数前，必须先把元素插入容器后。重载版本使用指定的比较操作。
  - sort_heap: 对指定范围内的序列重新排序，它假设该序列是个有序堆。重载版本使用自定义比较操作。

仿函数（Function object，仿函数(functor)又称之为函数对象（function object)
定义说明

重载了()操作符的struct

struct Add {
int operator()(int a, int b) { return a + b; }
};

Add add;
add(1, 2); // 3

STL仿函数常与STL算法结合使用,

1. 使用greater<int>仿函数对vector排序:
cpp
vector<int> v = {3, 1, 4, 2};
sort(v.begin(), v.end(), greater<int>()); 
// v is now {4, 3, 2, 1}
2. 使用plus<int>仿函数计算vector元素和:
cpp
vector<int> v = {1, 2, 3};
int sum = accumulate(v.begin(), v.end(), 0, plus<int>()); 
// sum is 6
3. 使用logical_not<bool>仿函数找出vector第一个非0元素:
cpp
vector<int> v = {0, 0, 1, 0};
auto it = find_if(v.begin(), v.end(), logical_not<bool>());
// it points to v[2] == 1 
4. 使用 modulus<int> 仿函数对vector进行求模运算:
cpp
vector<int> v = {1, 2, 3}; 
transform(v.begin(), v.end(), v.begin(), modulus<int>(2));
// v is now {1, 0, 1}
5. 使用equal_to<int>仿函数判断两个vector是否相等:
cpp 
vector<int> v1 = {1, 2, 3};
vector<int> v2 = {1, 2, 3};
bool equal = equal(v1.begin(), v1.end(), v2.begin(), equal_to<int>()); 
// equal is true

空间配制器（allocator)
定义说明
- 其中主要工作包括两部分
  - 1.对象的创建与销毁
  - 2.内存的获取与释放

Never-SayNever

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
STL总结

STLSTL（Standard Template Library），即标准模板库,被容纳于C++标准程序库（C++ Standard Library）中，该库包含了诸多在计算机科学领域里所常用的基本数据结构和基本算法。STL的六大组件容器（Container），是一种数据结构，以模板类的方法提供。为了访问容器中的数据，可以使用由容器类输出的迭代器；序列容器：每个元素都有固定位置，取决于插入时机和地点，和元素值无关。vector：vector是基于动态数组，内存空间是连续的，因此支持
复制链接

扫一扫