CinKate's Blogs HomeArchivesTagsCategoriesAbout
C++新特性系列四：STL
Word count: 7.1k|Reading time: 29 min

微软STL官方开发文档https://docs.microsoft.com/zh-cn/cpp/dotnet/stl-clr-library-reference?view=msvc-170

一、stl介绍与6大模块介绍

  1. stl的介绍：
  • stl就是（standard template library）的简称，定义在std命名空间中，定义了C++常用的容器与算法等。
  • 泛型编程的概念：用模板进行编程，可以实现一些其它方式难以实现的功能，但对于新手来说，泛型编程可能会难以理解，摸不着头脑。
    也就是说，模板是学习泛型编程的基础。
    注意：泛型编程不属于面向对象编程的范畴，泛型编程和面向对象编程是并列的。
  • stl作为泛型编程的最典型代表，它实现了其它编程方式难以实现的效果，比如将整个模板库分为六个部分，每个部分可以单独设计。举个最简单的例子，vector和map在数据结构方面完全不一样，但stl可以设计出“迭代器”这个模块，让该模块可以在不同的数据结构中按照同样的方式运行。这种技术没有泛型编程是难以实现的。
  1. 学习stl的注意事项
  • 学习stl一定要有全局观念，不要局限于单个容器，重点在于明白六大组件之间的联系。
  • 当然，如果只是单纯为了应付当前的业务，单独学一下某个容器的用法也没有问题。
  1. SLT的六大容器介绍：
  • 容器（container）：是一种数据结构，也就是真正用来存储数据的地方。分为三类
    • 顺序式容器：
    • 关联式容器：
    • 无序式容器：其实无序式容器也是一种关联式容器，但是既然C++标准委员会将无序容器与关联式容器平行的列了出来，那么我们这里也就让无序式容器和关联式容器平行吧。
  • 迭代器（iterator）：提供了可以访问任何容器的方法。
  • 算法（alogorithm）：用来操作容器中的数据的模板函数。
  • 仿函数（functor）
  • 适配器（adaptor）
  • 分配器（allocator）

二、容器

1. 顺序容器

顺序容器（sequence container）：每个元素都有固定的位置，位置取决于插入时间和地点，与元素的值无关

  • vector：将元素置于一个动态数组中，可以随机存储元素（也就是用索引直接存取）。

数组尾部添加或删除元素非常迅速。但在中部或头部就比较费时。

  • deque：“double end queue”的缩写，也就是双端队列。deque的实现相比于vector有些复杂，但本质仍然是优化过的动态数组，只不过相比于单纯的动态数组，在前面添加或删除元素非常快了。
    • 可以随机存储元素。头部和尾部添加或删除元素都非常快（略慢与vector）。但在 中间插入元素比较费时（和vector差不多）。
#include <iostream>
#include <vector>
#include <deque>
#include <set>
#include <algorithm>

int main()
{
    std::deque<int> ideque{1, 2, 3, 4};
    ideque.push_front(1); //在前面添加元素
    ideque.pop_front();   //在前面删除元素
    return 0;
}
  • list：本质就是链表，所以自然具有了链表的属性。
    • 不能随机存取元素（也就是list无法用索引存取元素）。在任何位置插入和删除元 素都比较迅速。（在任何位置插入删除元素的时间相同，在元素头部操作慢于deque，在元素尾部操作慢于deque和vector）
#include <iostream>
#include <vector>
#include <deque>
#include <set>
#include <algorithm>
#include<list>

int main()
{
    std::deque<int> ideque{1, 2, 3, 4};
    std::list<int> iList{1,2,3,4,5};
    iList.push_back(1);
    iList.push_front(1);
    iList.insert(++iList.begin(),1);
    return 0;
}

  • string：没什么好说的，就是把普通字符串封装了一下

    #include <iostream>
    #include <vector>
    #include <deque>
    #include <set>
    #include <algorithm>
    #include<list>

    int main()
    {
        const char *str="hello world";
        std::string st1("1111");
        return 0;
    }

  • forward_list：单项链表，简单来说就是受限的list，凡是list不支持的功能，它都不支持。做各种支持的操作效率都会高于list，最典型的就排序算法了，forword_list要优于list。

    • ForwordList 只提供前向迭代器，而不是双向迭代器。因此它也不支持反向迭代器。
    • ForwordList不提供成员函数 size()。
    • ForwordList 没有指向最末元素的锚点。基于这个原因，不提供用以处理最末元素的成员 back(),push_back(),pop_back()。

2. 关联容器

关联容器（associated container）：元素位置取决于元素的值，和插入顺序无关。

  • set/multiset：使用“红黑树”实现，是一种高度平衡的二叉树，二叉树的本质决定了set/multiset的元素存取值取决于元素本身的值，和插入顺序无关。

内部元素的值依据元素的值自动排列，与插入顺序无关。set内部相同数值的元素只能出现一次，multiset内部相同数值的元素可出现多次。容器用二叉树实现，便于查找。

#include <iostream>
#include <vector>
#include <deque>
#include <set>
#include <algorithm>
#include <list>

int main()
{
    std::set<int> iset{1, 3, 4, 5, 4, 4, 5};
    for (auto i : iset)
    {
        std::cout << i << std::endl;
    }
    std::multiset<int> imultiset{1, 3, 4, 5, 4, 4, 5};
    for (auto i : imultiset)
    {
        std::cout << i << std::endl;
    }

    return 0;
}
  • map/multimap：使用“红黑树”实现，是一种高度平衡的二叉树。

内部元素是成对的“key/value”，也就是“键值/实值”，内部元素依据其键值自动排序，map内部相同的键值只能出现一次，multimap则可以出现多次。

#include <iostream>
#include <vector>
#include <deque>
#include <set>
#include <algorithm>
#include <list>
#include <map>

int main()
{
    std::map<int, std::string> map1;
    map1.insert(std::pair<int, std::string>(1, "111"));
    map1.insert(std::pair<int, std::string>(2, "222"));
    map1.insert(std::pair<int, std::string>(3, "333"));
    map1.insert(std::pair<int, std::string>(4, "555"));
    for (auto const &elem : map1)
    {
        std::cout << elem.first << ":" << elem.second << std::endl;
    }
    std::multiset<int> imultiset{1, 3, 4, 5, 4, 4, 5};

    return 0;
}

3. 无序式容器（unordered container）

(1) unordered_map/unordered_multimap：使用“哈希表”实现的，由于哈希表的特性，实现了真正的无序。如果不理解为什么使用“哈希表”就是真正无序的，可以去百度一下“哈希表”，或者干脆直接记住就可以了。

使用方法也是“key/value”，和map/multimap类似。

(2) unordered_set/unorder_multiset：同样使用“哈希表”实现的。自然具有了哈希表实现的容器的特点。

使用方法和setl/multiset类似。

4. 关联式容器和无序式容器的对比：

  • 关联式容器都是有序的，对于那些对顺序有要求的操作，关联式容器效率会高很多。（比如增加元素，删除元素）
  • 无序容器都是真正的无序，在查找数据方面有着优势。（比如修改特定元素，查找元素）
  • 从内存消耗的角度讲，无序容器要高于关联容器不过这并不重要。

一句话来说，如果从这两类容器中选一个使用的话。如果是增加，删除元素比较频繁，就使用关联式容器。如果修改元素，查找元素比较平凡，就使用无序容器。

5. 我们在处理数据时应该选择什么容器呢？

  • 在我们需要使用存储“key/value”的容器时，只能使用map/multimap/unoredered_map/unordered_multimap。如果增加删除频繁，就使用map/multimap，修改，查找频繁，就使用unordered_map/unoredered_multimap。

在真正的大型项目中，常常会对这两种容器进行测试，普通练习靠感觉就可以了

  • 在处理普通元素：

    • 当元素需要频繁插入删除时，选择顺序容器。

      • 如果在尾部插入删除，选择vector
      • 在头部，尾部插入删除，选择deque
      • 在中间插入，删除，选择list

    • 当元素需要频繁查找时，选择.set/multiset/unorder_set/unorder_multiset。

      • 频繁增加，删除时，选set，
      • 频繁查找，修改时，选ordered_set

我们发现，对于普通元素，容器的选择不怎么容易判断。
其实在真正的大型项目中，要对各种容器进行测试的，普通练习一般选择vector或set就可以了。这两个使用是比较频繁的，

三、迭代器

  1. 迭代器介绍：迭代器提供了一种可以顺序访问容器各个元素的方法，可以让我们无视不同容器存储方式的不同，用同一的方式访问数据。经过前面对容器的学习，相信大家已经体会到这一点了。

  2. 迭代器的作用：能够让迭代器与容器，算法在设计，使用时互不干扰，又能无缝耦合起来。使用迭代器可以灵活操作各种容器算法，而不需要考虑不同容器间的差异。

四、算法

  1. stl的算法可以分为九个种类，具体有什么已经在“附录一”中完全列举了。
  • 查找算法：
  • 排序算法：
  • 删除和替换算法：
  • 排列组合算法：
  • 算数算法：
  • 生成和异变算法：
  • 关系算法：
  • 集合算法：
  • 堆算法：
  1. 查找算法(13个)：判断容器中是否包含某个值
  • adjacent_find:
    在iterator对标识元素范围内，查找一对相邻重复元素，找到则返回指向这对元素的第一个元素forwardIterator。否则返回最后一个元素的forwardIterator。
#include <iostream>
#include <vector>
#include <deque>
#include <set>
#include <algorithm>
#include <list>
#include <map>
#include <stack>
#include <queue>

int main()
{
    std::vector<int> ivec{1, 2, 3, 4, 5, 56, 6};
    auto iter = std::adjacent_find(ivec.cbegin(), ivec.cend()); //查找相邻元素(默认两个元素连续相等)，返回迭代器
    auto iter2 = std::adjacent_find(ivec.cbegin(), ivec.cend(), [](int elme1, int elme2)
                                    { return elme1 >= 4 && elme2 >= 4; });//两个元素均>=4 
    if (iter == ivec.cend())
    {
        std::cout << "container don't have adjacent element";
    }
    else
    {
        std::cout << std::distance(ivec.cbegin(), iter) << std::endl;
        std::cout << "container  have adjacent element";
    }

    return 0;
}
  • binary_search:
    在有序序列中查找value，找到返回true。重载的版本实用指定的比较函数对象或函数指针来判断相等。
#include <iostream>
#include <vector>
#include <deque>
#include <set>
#include <algorithm>
#include <list>
#include <map>
#include <stack>
#include <queue>

int main()
{
    std::vector<int> ivec{1, 2, 3, 4, 5, 56, 6};
    std::sort(ivec.cbegin(), ivec.cend(), [](int elem1, int elem2)
              { return elem1 > elem2; });
    //二分查找，存在返回true，不存在返回false
    auto item = std::binary_search(ivec.cbegin(), ivec.cend(), 3, [](int elem1, int elem2)
                                   { return elem1 > elem2; });//均为>

    return 0;
}
  • count:
    利用等于操作符，把标志范围内的元素与输入值比较，返回相等元素个数。
  • count_if:
    利用输入的操作符，对标志范围内的元素进行操作，返回结果为true的个数。
#include <iostream>
#include <vector>
#include <deque>
#include <set>
#include <algorithm>
#include <list>
#include <map>
#include <stack>
#include <queue>

int main()
{
    std::vector<int> ivec{1, 2, 3, 4, 5, 56, 6};
    std::cout << std::count(ivec.cbegin(), ivec.cend(), 4) << std::endl;
    //统计大于4的元素个数
    std::cout << std::count(ivec.cbegin(), ivec.cend(), [](int elem)
                            { return elem > 4; })
              << std::endl;
    return 0;
}
  • equal_range:
    注意，必须对有序容器进查找，下面的lower_bound和upper_bound也是同理。
    功能类似equal，返回一对iterator，第一个表示lower_bound，第二个表示upper_bound。
  • find利用底层元素的等于操作符，对指定范围内的元素与输入值进行比较。当匹配时，结束搜索，返回该元素的一个InputIterator。

  • find_end:
    在指定范围内查找”由输入的另外一对iterator标志的第二个序列”的最后一次出现。找到则返回最后一对的第一个迭代器，否则返回输入的”另外一对”的第一个迭代器。重载版本使用用户输入的操作符代替等于操作。

    #include <iostream>
    #include <vector>
    #include <deque>
    #include <set>
    #include <algorithm>
    #include <list>
    #include <map>
    #include <stack>
    #include <queue>

    int main()
    {
        std::vector<int> ivec1{4, 5};
        std::vector<int> ivec{1, 2, 3, 4, 5, 56, 6, 2, 1, 3, 4, 5, 6, 6};
        auto iter = std::find_end(ivec.cbegin(), ivec.cend(), ivec1.cbegin(), ivec1.cend());
        std::cout << std::distance(ivec.cbegin(), iter)
                  << std::endl;
        return 0;
    }

  • find_first_of:
    在指定范围内查找”由输入的另外一对iterator标志的第二个序列”中任意一个元素的第一次出现。重载版本中使用了用户自定义操作符。

  • find_if:
    使用输入的函数代替等于操作符执行find。

#include <iostream>
#include <vector>
#include <deque>
#include <set>
#include <algorithm>
#include <list>
#include <map>
#include <stack>
#include <queue>

int main()
{
    std::vector<int> ivec1{4, 5};
    std::vector<int> ivec{1, 2, 3, 4, 5, 56, 6, 2, 1, 3, 4, 5, 6, 6};
    //第一次出现 vec位置
    auto iter = std::find_first_of(ivec.cbegin(), ivec.cend(), ivec1.cbegin(), ivec1.cend());
    std::cout << std::distance(ivec.cbegin(), iter)
              << std::endl;
    auto iter2 = std::find_if(ivec.cbegin(), ivec.cend(), [](int elem)
                              { return elem && elem % 2; });
    return 0;
}
  • lower_bound:
    返回一个iterator，指向在有序序列范围内的可以插入指定值而不破坏容器顺序的第一个位置。重载函数使用自定义比较操作。
  • upper_bound:
    返回一个iterator，指向在有序序列范围内插入value而不破坏容器顺序的最后一个位置，该位置标志一个大于value的值。重载函数使用自定义比较操作。
  • search:
    这两个是真的不好描述，去微软官网查看一下吧，简单，比我在这里总结的强多了。
  • search_n:
  1. 排序和通用算法(14个)：提供元素排序策略
    inplace_merge:
    merge:
    nth_element:
    partial_sort:
    partial_sort_copy:
    partition:
    random_shuffle:
    reverse:
    reverse_copy:
    rotate:
    rotate_copy:
    sort:
    stable_sort:
    stable_partition:
#include <iostream>
#include <vector>
#include <deque>
#include <set>
#include <algorithm>
#include <list>
#include <map>
#include <stack>
#include <queue>

int main()
{
    //merge
    std::vector<int> ivec1{4, 5};
    std::vector<int> ivec{1, 2, 3, 4, 5, 56, 6, 2, 1, 3, 4, 5, 6, 6};
    std::vector<int> ivec_merge;
    std::sort(ivec1.cbegin(), ivec1.cend());
    std::sort(ivec.cbegin(), ivec.cend());
    std::merge(ivec1.cbegin(), ivec1.cend(), ivec.cbegin(), ivec.cend(), ivec_merge.begin());
    for (auto item : ivec_merge)
    {
        std::cout << item;
    }

    //随机打乱
    std::random_shuffle(ivec1.cbegin(), ivec1.cend());
    for (auto item : ivec1)
    {
        std::cout << item;
    }
    return 0;
}
  1. 删除算法(15个)
    copy:
    copy_backward:
    iter_swap:
    remove:
    remove_copy:
    remove_if:
    remove_copy_if:
    replace:
    replace_copy:
    replace_if:
    replace_copy_if:
    swap:
    swap_range:
    unique:
    unique_copy:
#include <iostream>
#include <vector>
#include <deque>
#include <set>
#include <algorithm>
#include <list>
#include <map>
#include <stack>
#include <queue>

int main()
{
    std::vector<int> ivec1{4, 5};
    std::vector<int> ivec{1, 2, 3, 4, 5, 56, 6, 2, 1, 3, 4, 5, 6, 6};
    std::remove(ivec1.cbegin(), ivec1.cend(), 3); //删除
    std::unique(ivec1.cbegin(), ivec1.cend(), 3); //将3放在最后位置
    return 0;
}
  1. 排列组合算法(2个)：提供计算给定集合按一定顺序的所有可能排列组合
    next_permutation:
    prev_permutation:
  2. 算术算法(4个)
    accumulate:
    partial_sum:
    inner_product:
    adjacent_difference:
  3. 生成和异变算法(6个)
    fill:
    fill_n:
    for_each:
    generate:
    generate_n:
    transform:
#include <iostream>
#include <vector>
#include <deque>
#include <set>
#include <algorithm>
#include <list>
#include <map>
#include <stack>
#include <queue>

int main()
{
    std::vector<int> ivec1{4, 5};
    std::vector<int> ivec{1, 2, 3, 4, 5, 56, 6, 2, 1, 3, 4, 5, 6, 6};
    std::for_each(ivec1.cbegin(), ivec1.cend(), [](int ele)
                  { return ele + 1; });//对每个元素进行+1

    return 0;
}
  1. 关系算法(8个)
    equal:
    includes:
    lexicographical_compare:
    max:
    max_element:
    min:
    min_element:
    mismatch:
  2. 集合算法(4个)
    set_union:
    set_intersection:
    set_difference:
    set_symmetric_difference:
  3. 堆算法(4个)
    make_heap:
    pop_heap:
    push_heap:
    sort_heap:

五、仿函数

  1. 仿函数定义：就是一个可以调用“()”运算符的类对象，将operator()重载的类的对象就是仿函数。

简单来说，就是我们在用算法时最后一个参数需要一个可调用对象，stl本身已经帮我们定义了很多可调用对象，不用我们自己再去定义了。

#include <iostream>
#include <vector>
#include <deque>
#include <set>
#include <algorithm>
#include <list>
#include <map>

int main()
{
    std::plus<int> iplus;
    std::cout << iplus(1, 2) << std::endl;
    std::vector<int> vec = {1, 3, 4, 5, -1, 2, 3};
    std::sort(vec.begin(), vec.end(), [](int ele1, int ele2)
              { return ele1 > ele2; });
    //使用可调用对象
    std::sort(vec.begin(),vec.end(),std::greater<int>());
    for (auto item : vec)
    {
        std::cout << item << std::endl;
    }

    return 0;
}

六、适配器与分配器

  1. 什么是容器适配器：“适配器是使一种事物的行为类似于另外一种事物行为的一种机制”。适配器对容器进行包装，使其表现出另外一种行为。例如：stack 实现了栈的功能，内部默认使用deque容器来存储数据。

  2. STL的适配器有哪些：标准库提供了三种顺序容器适配器，没有关联型容器的适配器。分别是queue（队列），priority_queue（优先级队列），stack（栈）。

  3. 适配器的使用：
  • 要使用适配器，首先需要引入对应的头文件
    • 要使用stack， 需要#include
    • 要使用queue或priority_queue， 需要#include
  • 适配器的初始化：
    • 普通的初始化方式： stack stk。
    • 覆盖默认容器类型的初始化方式： stack<int, vector> stk
#include <iostream>
#include <vector>
#include <deque>
#include <set>
#include <algorithm>
#include <list>
#include <map>
#include <stack>
#include <queue>

int main()
{
    std::stack<int> iStack;
    iStack.push(1);
    iStack.push(2);
    std::cout << iStack.top() << std::endl;

    std::queue<int> iqueue;
    iqueue.push(1);
    iqueue.push(2);
    std::cout << iqueue.front() << std::endl;

    return 0;
}
  1. 分配器提一下就可以了。在分配动态内存时，直接使用new，delete容易产生内存碎片化的问题，不同的分配器有不同的分配内存的方法，可以大幅提高程序对堆内存的使用效率，我们直接使用默认的分配器就可以了

附录： STL各种容器的操作

1. vector的各种函数

1.构造函数

  1. vector()：创建一个空的vector
  2. vector(const std::allocator& al)：使用指定的分配器来分配内存。allocator就是一个内存分配器，vector已经指定了默认的分配器了，不需要我们去主动调用，以后设计allocator直接忽略就可以了，其实这个构造函数只不过是用指定的分配器去创建一个空的vector罢了。
  3. vector(std::vector&& right, const std::allocator& al)：就是移动构造函数，第二个参数表示我们指定分配器。
  4. vector(const std::vector& vec, const std::alloctor& al)：就是复制构造函数，分配器可以自己指定，当然，一般来说，vector默认的分配器就够用了。
  5. vector(std::initializer_list& initList, const std::allocator& al)：就是使用initializer_list来初 始化容器，第二个参数表示我们可以指定分配器。
  6. vector(iter first, iter last, const std::allocator& al)：就是容器初始有迭代器[first, last)的内容（这里使用deque，list的迭代器也可以），第三个参数还是表示我们可以指定分配器。
  7. vector(const size_t count, const std::alloctor& al)：创建一个vector，元素个数为count。元素均为默认值，如果是普通类型，则赋值为0。如果是类类型，则均使用默认构造函数进行初始化。
  8. vector(const size_t count，const T& t)：创建一个vector，元素个数为count，且值均为t。
#include <iostream>
#include <vector>
#include <deque>
#include <set>

int main()
{
    std::vector<int> ivec{1, 2, 3, 4};
    std::vector<int> ivec2(100); // 100个元素，每个元素都是0
    std::vector<int> ivec3(100,5); // 100个元素，每个元素都是5
    for (auto item : ivec2)
    {
        std::cout << item << std::endl;
    }

    std::deque<int> ideque{1, 2, 3, 4, 4};
    std::set<int> iset{1, 2, 3, 4, 5};
}

2. 增加函数

  1. void push_back(const T& value)：向容器尾部增加一个元素value。
  2. void push_back(T&& value)：向容器尾部增加一个元素value，这不过这次以右值引用的形式添加。
  3. std::vector::iterator insert(std::vector::const_iterator& where, std::initializer_list initList)：在where迭代器指定的地方添加initList，返回值为指向新添加的第一个元素的迭代器，insert函数虽然有很多重载，但返回值是完全类似的，所以接下来insert函数的返回值就不介绍了。
  4. std::vector::iterator insert(std::vector::const_iterator& where, iter first, iter last)：将迭代器[first, last)添加到迭代器where指定的位置。
  5. std::vector::iterator insert(std::vector::const_iterator& where, size_t count, const int& value)：在where处插入count个value。
  6. std::vector::iterator insert(std::vector::const_iterator& where, const T& value)：在where处插入value。
  7. std::vector::iterator insert(std::vector::const_iterator& where, T&& value)：在where处插入value，只不过这次以右值引用的形式插入了。
#include <iostream>
#include <vector>
#include <deque>
#include <set>
#include <algorithm>

int main()
{
    std::vector<int> ivec2{1, 2, 3, 4};
    //追加函数
    ivec2.push_back(10);
    ivec2.push_back(20);
    //插入函数
    auto iter = ivec2.insert(++ivec2.cbegin(), 100); //返回值为插入的第一个元素迭代器，这儿返回第二个元素100

    std::cout << std::distance(ivec2.begin(), iter) << std::endl; //返回1
    for (auto item : ivec2)
    {
        std::cout << item << std::endl;
    }

    auto iter2 = ivec2.insert(++ivec2.cbegin(), {1, 2, 3, 4, 5, 6}); //添加一个初始化列表

    auto iter2 = ivec2.insert(++ivec2.cbegin(), 3, 40); //添加3个40
}

3. 删除函数

  1. std::vector::iterator erase(std::vector::const_iterator where)：删除容器迭代器指向的元素。返回指向被删除元素后面的那个元素的迭代器。
  2. iterator erase(iterator first, iterator last)：删除容器中[first, last)中的元素。返回指向被删除元素后面的那个元素的迭代器。
  3. void pop_back()：删除容器中最后一个元素。
  4. clear()：删除容器中所有元素。

4. 遍历函数

  1. T& at(const size_t pos)：返回pos位置元素的引用。
  2. const T& at(const size_t pos) const：at函数的常量版本。
  3. T& front()：返回首元素的引用。
  4. const T& front() const：front函数的常量版本。
  5. T& back()：返回尾元素的引用。
  6. const T& back() const：back函数的常量版本。
  7. std::vector::iterator begin()：返回指向容器第一个元素的迭代器。
  8. std::vector::const_iterator begin() const：begin函数的常量版本。
  9. std::vector::const_iterator cbegin() const：可以主动调用的begin函数的常量版本。
  10. std::vector::iterator end()：返回指向容器最后一个元素的下一个元数的迭代器。
    end()函数也有两个常量版本，和begin类似，就不写了。
  11. std::vector::reverse_iterator rbegin()：反向迭代器，指向最后一个元素。
    同样有两个常量版本。
  12. reverse_iterator rend()：反向迭代器，指向第一个元素之前的元素。
    同样有两个常量版本。
#include <iostream>
#include <vector>
#include <deque>
#include <set>
#include <algorithm>

int main()
{
    std::vector<int> ivec2{1, 2, 3, 4};
    //遍历函数
    auto item = ivec2.at(0);    // at
    int &item2 = ivec2.front(); //返回首个元素(返回的是引用)
    item2 = 222;
    int &item3 = ivec2.back(); //返回最后一个元素(返回的是引用)
    item3 = 222;
    std::cout << item << std::endl;
    for (auto item : ivec2)
    {
        std::cout << item << std::endl;
    }

    // crbegin返回最后一个元素，crend返回第一个元素
    for (auto iter = ivec2.crbegin(); iter != ivec2.crend(); iter++)
    {
        std::cout << (*iter) << std::endl;
    }
}

5. 判断函数

  1. bool empty() const：判断容器是否为空，若未空，则返回true，否则返回false。
#include <iostream>
#include <vector>
#include <deque>
#include <set>
#include <algorithm>

int main()
{
    std::vector<int> ivec2{1, 2, 3, 4};
    //判断函数
    std::cout << ivec2.empty() << std::endl; //为空返回1,否则返回0
    for (auto item : ivec2)
    {
        std::cout << item << std::endl;
    }
}

6. 大小函数

  1. size_t size() const：返回当前容器中元素的个数。
  2. size_t capacity() const：返回当前容器不扩张所能容纳的最大元素数量。
  3. size_t max_size() const：返回当前机器可以存储的元素数量最大值。
#include <iostream>
#include <vector>
#include <deque>
#include <set>
#include <algorithm>

int main()
{
    std::vector<int> ivec2{1, 2, 3, 4};
    //大小函数
    std::cout << ivec2.size() << std::endl;
    std::cout << ivec2.capacity() << std::endl;//不扩容的情况下，容量大小
    std::cout << ivec2.max_size() << std::endl;//扩容的情况下，最大容量大小 4611686018427387903
    for (auto item : ivec2)
    {
        std::cout << item << std::endl;
    }
}

7. 其它函数

  1. void swap(std::vector & vec)：交换两个同类型容器的的数据。
  2. void assign(int n, const T& x)：将容器设置为n个x。
  3. void assign(const_iterator first, const iterator last)：将当前容器的元素设置为[first, last)。
    first,last都是迭代器，可以不是vector类型的迭代器，deque，list类型也可以。
  4. void assign(const std::initialize_list initList)：将容器元素设置为initialize_list的元素。
  5. void resize(size_t newSize)：将容器的容量设置为newSIze。
#include <iostream>
#include <vector>
#include <deque>
#include <set>
#include <algorithm>

int main()
{
    std::vector<int> ivec2{1, 2, 3, 4};
    std::vector<int> ivec3{4, 5, 6, 7};
    //交换函数
    ivec2.swap(ivec3);
    //重置函数
    ivec2.assign({1,3,4,5,5,67});
    ivec2.assign(ivec2.begin(),ivec2.begin()+2);
    ivec2.assign(10,9);//设置10个元素，每个元素初始为9
    //重新设置大小
    ivec2.resize(20);
    ivec2.resize(2);//只保留开始两个元素
    for (auto item : ivec2)
    {
        std::cout << item << std::endl;
    }
}

2. deque的各种函数：

deque的各种函数与vector类似，我就不再重复一遍了。
这里只介绍vector不同的地方：

deque支持在容器前面插入删除，操作。也就是支持以下的三个函数

  • void push_front(const T& value）；
  • void push_front(T&& value)；
  • void pop_front()；

3. list的各种函数

list和deque类似，只讲一下和deque不同的部分。list都用支持在前面，后面增加，删除。

list和deque在函数上的唯一区别就是不支持随机缩影，也就是不支持at函数。

4. string的各种函数

string虽然也是顺序容器，但因为本质是对字符串的封装，所以和其它容器在用法上有较大区别。

  1. 获取封装字符串的函数。
  • const char* c_str() const：返回string对象内部的函数的指针。注意，c_str()函数返回的直接就是string对象内部的指针，也就是说string对象指向的对象发生了改变，返回的对象也会发生改变的。
  • const char* data()const：返回string对象内部的函数指针。和c_str()函数的区别就是返回的字符串后面没有’\0’。
  • size_t copy(char* const ptr, size_t count, const size_t off) const：

讲string对象的一部分复制到ptr数组中。
ptr表示复制到哪个数组。
count表示复制string对象的几个字符
off表示从string的哪个字符开始复制。

  1. 字符串比较函数。
    compare函数：这个函数重载比较多，用的时候在vs中查看一下就可以了。可以用string对象的任意部分与另一个字符串进行比较，

其它函数就和vector类似了，同样支持随机选取，支持容器末尾插入。

#include <iostream>
#include <vector>
#include <deque>
#include <set>
#include <algorithm>
#include<list>

int main()
{
    const char *str="hello world";
    std::string st1("1111");
    std::cout<<st1.c_str()<<std::endl;//返回c语言类型的const char *
    std::cout<<st1.data()<<std::endl;//结尾无\0
    st1.compare("!22222");//字符串比较
    return 0;
}

5. forward_list:

和list差不多，只不过是没有size()函数，没有push_back和pop_back函数。

Author: CinKate
Link: http://renxingkai.github.io/2022/08/29/cpp-stl/
Copyright Notice: All articles in this blog are licensed under CC BY-NC-SA 4.0 unless stating additionally.
C++