当前位置: 首页>编程语言>正文

bitwardenrs容器 liberty容器

   STL学习笔记

目录

一、容器

二、容器方法

***  1.vector 动态数组  ***

***2.deque  双端队列***

***  3.list   双向链表  ***

***  4.set  关联容器,不允许有重复的  ***

***  5.multiset 可以有重复  ***

***  6.unordered_set / unordered_multiset   ***

***  7.map  关联容器,“键-值”对 唯一  ***

***  8.multimap “键-值”对 键可重复  ***

***  9.unordered_map / unordered_multimap   ***

***  10.stack  LIFO  “栈”  ***

***  11.queue  FIFO "队列"  ***

***  12.priority-queue   优先队列  ***

***  13.string  字符串   ***


一、容器

在STL中实现的容器有如下:

| Container      | Description                  | Header File | Iterator(迭代器) |
| -------------- | ---------------------------- | ----------- | ---------------- |
| vector         | 动态数组                     | <vector>    | Random Access    |
| list           | "链表"                       | <list>      | Bidirectional    |
| deque          | 双端队列                     | <deque>     | Random Access    |
| set            | 关联容器,不允许有重复的     | <set>       | Bidirectional    |
| multiset       | 关联容器,允许有重复元素     | <set>       | Bidirectional    |
| map            | 关联容器,“键-值”对 唯一     | <map>       | Bidirectional    |
| multimap       | 关联容器,“键-值”对 键可重复 | <map>       | Bidirectional    |
| stack          | LIFO  “栈”                   | <stack>     | No Iterator      |
| queue          | FIFO "队列"                  | <queue>     | NO Iterator      |
| priority-queue | 优先队列                     | <queue>     | NO Iterator      |

容器分类:
- Sequence Container 顺序容器
  - vector
  - deque
  - list
- Associate Container 关联容器
  - set
  - multiset
  - map
  - multimap
- Derived Container 派生容器
  - stack
  - queue
  - priority-queue

二、容器方法

***  1.vector 动态数组  ***

--insert 插入
(1)insert( const_iterator pos, T&& value );  在指定位置前插入 value
     例子:insert(v.begin(),1)   在首位前插入元素1

(2)insert( const_iterator pos, size_type count, const T& value );    在指定位置前插入 count 个 value
     例子:insert(v.begin(),5,,1)   在首位前插入 5 元素 1

 (3) insert( const_iterator pos, InputIt first, InputIt last );     在指定位置前插入 [first,last) 里的元素
     注意:若 InputIt 为整数类型,则此重载与重载 (2) 拥有相同效果。
     例子 insert(v.begin(),1,,5)   则在首位前插入一个 5

--push_back   在末尾插入元素
  例子:push_back(1)   在末尾插入元素 1

--pop_back    删除末尾元素元素
  例子: v.pop_back()

--clear  清除容器内全部内容
  例子: v.clear()

--emplace  原位构造函数
    emplace( const_iterator pos, Args&&... args );      在 pos 前构造元素
    例子:v.(v.begin(),1)         在首位前构造元素 1

--emplace_back
    emplace_back( Args&&... args );  在末尾构造元素
    例子:v.emplace_back(1)  在在末尾后构造元素 1

--erase  擦除元素
 (1) erase( const_iterator pos );    移除位于 pos 的元素。
      例子:v.erase(v.begin());      移除位于首位的元素

 (2) erase( const_iterator first, const_iterator last );   移除范围 [first; last) 中的元素。
      例子: v.erase(v.begin(),v.end());     移除范围 [v.begin(),v.end()) 中的元素

 注意:end()不能为 pos 值

 (3) template< class T, class Alloc, class U >
     void erase(std::vector<T,Alloc>& c, const U& value);
    从容器中擦除所有比较等于 value 的元素

 (4) template< class T, class Alloc, class Pred >
     void erase_if(std::vector<T,Alloc>& c, Pred pred);
    从容器中擦除所有满足 pred 的元素

--reserve   预留存储空间
  void reserve( size_type new_cap );
增加 vector 的容量到大于或等于 new_cap 的值。若 new_cap 大于当前的 capacity() ,则分配新存储,否则该方法不做任何事。
reserve() 不更改 vector 的 size 。

--resize    改变容器中可存储元素的个数
   void resize( size_type count ); 
   重设容器大小以容纳 count 个元素。
   若当前大小大于 count ,则减小容器为其首 count 个元素。
  
--swap 交换
   void swap( vector& other )
  将内容与 other 的交换。不在单个元素上调用任何移动、复制或交换操作。

--empty 检查容器是否为空
  bool empty()

--size  返回容纳的元素数
  size_type size()

--max_size 返回可容纳的最大元素数
  size_type max_size()  

--capacity  返回当前存储空间能够容纳的元素数
  size_type capacity()

--shrink_to_fit   通过释放未使用的内存减少内存的使用
  void shrink_to_fit();   
  请求移除未使用的容量。
  它是减少 capacity() 到 size()非强制性请求。请求是否达成依赖于实现。

***2.deque  双端队列***
 

和 vector 基本相同

扩展:
 --push_front  插入元素到容器起始
 --pop_front   移除首元素
 --emplace_front  在容器头部就地构造元素

***  3.list   双向链表  ***
 

和 deque 基本相同

扩展:
--merge  合并二个已排序列表
 void merge( list&& other );   
      归并二个已排序链表为一个。链表应以升序排序。不复制元素。操作后容器 other 变为空。若 other 与 *this 指代同一对象则函数不做任何事

--splice  从另一个list中移动元素
 (1) void splice( const_iterator pos, list&& other );
    从 other 转移所有元素到 *this 中。元素被插入到 pos 所指向的元素之前。
    操作后容器 other 变为空。若 other 与 *this 指代同一对象则行为未定义。

 (2)void splice( const_iterator pos, list&& other, const_iterator it );
    从 other 转移 it 所指向的元素到 *this 。元素被插入到 pos 所指向的元素之前。

 (3)void splice( const_iterator pos, list&& other,const_iterator first, const_iterator last );
    从 other 转移范围 [first, last) 中的元素到 *this 。元素被插入到 pos 所指向的元素之前。
    若 pos 是范围 [first,last) 中的迭代器则行为未定义。

--reverse  将该链表的所有元素的顺序反转

--unique   删除连续的重复元素
  size_type unique();  从容器移除所有 相继 的重复元素。只留下相等元素组中的第一个元素。

--sort  对元素进行排序
 (1)void sort();    以升序排序元素
 
 (2)template< class Compare >
    void sort( Compare comp );
    例子:l.sort(greater<int>());  升序排列
          l.sort(less<int>());     降序排列

--remove/remove_if                移除所有满足特定标准的元素
  (1)size_type remove( const T& value );
  例子:l.remove(1)       移除全部 1 元素

  (2) template< class UnaryPredicate >
     size_type remove_if( UnaryPredicate p );
     例子:l.remove_if([](int n){  return n > 10;  })  移除全部大于 10 的元素

***  4.set  关联容器,不允许有重复的  ***
 

--insert 
 (1)std::pair<iterator,bool> insert( value_type&& value ); 插入元素
  例子:s.insert(1);   插入元素 1

 (2)template< class InputIt >
    void insert( InputIt first, InputIt last );       插入 [first,last) 范围内的元素
    例子: int a[]={1,2,3};
           s.insert(a,a+3);     插入 [a,a+3) 范围内的元素             

--empty 
--clear
--size
--max_size
--swap

--erase 移除元素
 (1)iterator erase( iterator pos );   移除位于 pos 位置的元素

 (2)iterator erase( const_iterator first, const_iterator last );   移除范围 [first; last) 中的元素,它必须是 *this 中的合法范围

 (3)size_type erase( const key_type& key );           移除关键等于 key 的元素(若存在一个)

--emplace
  template< class... Args >
  std::pair<iterator,bool> emplace( Args&&... args );
  若容器中无拥有该关键的元素,则插入以给定的 args 原位构造的新元素到容器。

--emplace_hint
  template <class... Args>
  iterator emplace_hint( const_iterator hint, Args&&... args );
  插入新元素到容器中尽可能接近于恰在 hint 前的位置。原位构造元素,即不进行复制或移动操作。

--merge     从另一容器接合结点(C++17)
  
--count    返回匹配特定键的元素数量 (因为没有重复元素,所以一般为 1 或 0)

--find   寻找带有特定键的元素

--contains   检查容器是否含有带特定关键的元素 (c++20)

--equal_range   返回容器中所有拥有给定关键的元素范围。范围以二个迭代器定义,一个指向首个不小于 key 的元素,
                另一个指向首个大于 key 的元素
  
--lower_bound   返回指向首个不小于给定键的元素的迭代器

--upper_bound   返回指向首个大于给定键的元素的迭代器

***  5.multiset 可以有重复  ***

和set一样,区别在于可以元素重复

***  6.unordered_set / unordered_multiset   ***

体内实现了哈希表,是无序的,查找时间为常量级(单个)

***  7.map  关联容器,“键-值”对 唯一  ***

--empty
--size
--max_size
--erase  与set类似 三种方法
--clear    清除容器内全部内容

--merge     从另一容器接合结点(C++17)
  
--count    返回匹配特定键的元素数量 (因为没有重复元素,所以一般为 1 或 0)

--find   寻找带有特定键的元素

--contains   检查容器是否含有带特定关键的元素 (c++20)

--equal_range   返回容器中所有拥有给定关键的元素范围。范围以二个迭代器定义,一个指向首个不小于 key 的元素,
                另一个指向首个大于 key 的元素
  
--lower_bound   返回指向首个不小于给定键的元素的迭代器

--upper_bound   返回指向首个大于给定键的元素的迭代器--insert  插入元素
 (1) std::pair<iterator,bool> insert( value_type&& value );     插入 value 
    例子:(6种方法)

map<int,string>  m;
            m[1] = "hh";
            m.insert(map<int,string>::value_type(2,"ss"));
            m.insert(pair<int,string>(3,"ee"));
            m.insert(make_pair<int,string>(4,"gg"));
            m.insert({6,"ww"});
            m.insert({{7,"tt"},{8,"oo"}}); 
            (注意:此为列表模式 如:{map<int,string>::value_type(2,"ss"),map<int,string>::value_type(2,"ss")}也可以)

            for(auto i = m.begin(); i != m.end(); ++i)
            {
                cout << "key:" << i->first << "   value:" << i->second << endl;
            }

 (2) iterator insert( const_iterator hint, value_type&& value );   插入 value 到尽可能接近
    例子:  m.insert(m.begin(),pair<int,string>(5,"aa"));
  

***  8.multimap “键-值”对 键可重复  ***

与map类似 
--inseert (5种方法)
         

multimap<int,string>  m;
            m.insert(map<int,string>::value_type(2,"ss"));
            m.insert(pair<int,string>(3,"ee"));
            m.insert(make_pair<int,string>(4,"gg"));
            m.insert({6,"ww"});
            m.insert({{7,"tt"},{8,"oo"}});

***  9.unordered_map / unordered_multimap   ***

使用方法和map一样
体内实现了哈希表,是无序的,查找时间为常量级(单个)

***  10.stack  LIFO  “栈”  ***

注意:stack<int> 等价于 stack<int,deque<int>>  即 默认使用 deque
注意:stack是一个适配器   
stack的三种写法
    satck<int,vector<int>> 、stack<int,list<int>> 、 stack<int,deque<int>>
注意:stack<int> 等价于 stack<int,deque<int>>

--top      访问栈顶元素     返回 stack 中顶元素的引用
--empty
--size
--push  向栈顶插入元素
--pop   删除栈顶元素
--emplace   于顶原位构造元素
--swap

***  11.queue  FIFO "队列"  ***

注意queue是一个适配器   
注意: queue<int> 等价于  queue<<int,deque<int>>  即 默认使用 deque
queue的写法 queue<int,list<int>> 、 queue<int,deque<int>>

--empty
--size
--push     向队列尾部插入元素
--pop      删除栈顶元素
--emplace    于尾部原位构造元素
--swap
--front   访问第一个元素
--back    访问最后一个元素

***  12.priority-queue   优先队列  ***

注意queue是一个适配器   分为最大优先值排序、最小优先值排序

注意: priority_queue<int> 等价于  priority_queue<<int,vector<int>>  即 默认使用 vector
queue的写法 priority_queue<int,deque<int>> 、 priority_queue<int,vector<int>>

注意:queue默认由大到小排序  即  

      priority_queue<int> pq;
      pq.push(2);
      pq.push(1);
      py.push(4);
      py.push(3);
其内部排序为 4 3 2 1

想要按由最小优先值排序可加greater  如 priority_queue<int,deque<int>,greater<int>>

--top      访问栈顶元素   
--empty
--size
--push  插入元素,并对底层容器排序
--pop   删除栈顶元素
--emplace   原位构造元素并排序底层容器
--swap

***  13.string  字符串   ***

--size()/length() :返回字符串的长度,实际字符的个数,不包含'\0'
  如: s1.size(), s1.length()

--at(): 返回字符串中指定位置的那个字符,如果指定位置超过字符串的长度(越界),就会抛出异常.
  如:
    char ch = s1.at(5); 

--c_str() :将C++中的字符串对象转换成C语言中的字符串(const char*)
    如: 
      const char* p = s1.c_str();

--empty() :判断字符串是否为空,返回值为bool类型
    如:
        if (s1.empty())
        {}
--find() : 查找指定的字符或字符串,返回字符或字符串首次出现的位置(下标)
    如:
        str.find('a', 2) ;//从下标2的位置开始查找字符 'a'
        str.find(str1) ;//查找字符串str1在str中首次出现的位置

--substr(): 裁剪字符串
    如:
        str.substr(2) ; //从下标2的位置开始裁剪,舍弃前两个字符
        str.substr(3,2); //从下标3的位置开始裁剪,裁剪两个字符

--swap():  交换两个字符串的内容
    如: 
        str.swap(str1)

--clear(): 清除字符串的内容
    如 : 
        str.clear()

--find
--compare  比较二个字符串
--max_size
--begin
--front
--end
--back
--data   返回指向字符串首字符的指针
--reserve   保留存储
--capacity  返回当前对象分配的存储空间能保存的字符数量
--shrink_to_fit   通过释放不使用内存减少内存使用
--starts_with      检查 string 是否始于给定前缀
--ends_with   检查 string 是否终于给定后缀

--copy 
   size_type copy( CharT* dest,
                size_type count,
                size_type pos = 0) const;
复制子串 [pos, pos+count) 到 dest 所指向的字符串


https://www.xamrdz.com/lan/5w51963255.html

相关文章: