STL 模板库第七日 : List

最新推荐文章于 2024-03-19 01:19:55 发布
最新推荐文章于 2024-03-19 01:19:55 发布
阅读量153 收藏
点赞数
分类专栏： STL模板库温习之路
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32378713/article/details/79336396
版权

一：List基础
List简介
   list是一个双向链表容器，可高效地进行插入删除元素。
   list不可以随机存取元素，所以不支持at.(pos)函数与[]操作符。It++(ok) it+5(err)
  #include <list>  

list对象的默认构造
list采用采用模板类实现,对象的默认构造形式：list<T> lstT;  如：
list<int> lstInt;            //定义一个存放int的list容器。
list<float> lstFloat;     //定义一个存放float的list容器。
list<string> lstString;     //定义一个存放string的list容器。
...                    
//尖括号内还可以设置指针类型或自定义类型。
list头尾的添加移除操作
    list.push_back(elem);       //在容器尾部加入一个元素
    list.pop_back();              //删除容器中最后一个元素
    list.push_front(elem);     //在容器开头插入一个元素
    list.pop_front();              //从容器开头移除第一个元素

    list<int> lstInt;
    lstInt.push_back(1);
    lstInt.push_back(3);
    lstInt.push_back(5);
    lstInt.push_back(7);
    lstInt.push_back(9);
    lstInt.pop_front();
    lstInt.pop_front();
    lstInt.push_front(11);
    lstInt.push_front(13);
    lstInt.pop_back();
    lstInt.pop_back();
// lstInt    {13,11,5}
list的数据存取
   list.front();   //返回第一个元素。
   list.back();  //返回最后一个元素。

list<int> lstInt;
    lstInt.push_back(1);
    lstInt.push_back(3);
    lstInt.push_back(5);
    lstInt.push_back(7);
    lstInt.push_back(9);

    int iFront = lstInt.front();    //1
    int iBack = lstInt.back();        //9
    lstInt.front() = 11;            //11
    lstInt.back() = 19;            //19
list与迭代器
    list.begin();                     //返回容器中第一个元素的迭代器。
    list.end();                       //返回容器中最后一个元素之后的迭代器。
    list.rbegin();         //返回容器中倒数第一个元素的迭代器。
    list.rend();         //返回容器中倒数最后一个元素的后面的迭代器。

    list<int> lstInt;
    lstInt.push_back(1);
    lstInt.push_back(3);
    lstInt.push_back(5);
    lstInt.push_back(7);
    lstInt.push_back(9);

    for (list<int>::iterator it=lstInt.begin(); it!=lstInt.end(); ++it)
    {
        cout << *it;
        cout << " ";
    }

    for (list<int>::reverse_iterator rit=lstInt.rbegin(); rit!=lstInt.rend(); ++rit)
    {
        cout << *rit;
        cout << " ";
    }
list对象的带参数构造
    list(beg,end);    //构造函数将[beg, end)区间中的元素拷贝给本身。注意该区间是左闭右开的区间。
    list(n,elem);   //构造函数将n个elem拷贝给本身。
    list(const list &lst);  //拷贝构造函数。

list<int> lstIntA;
    lstIntA.push_back(1);
    lstIntA.push_back(3);
    lstIntA.push_back(5);
    lstIntA.push_back(7);
    lstIntA.push_back(9);

    list<int> lstIntB(lstIntA.begin(),lstIntA.end());        //1 3 5 7 9
    list<int> lstIntC(5,8);                            //8 8 8 8 8
    list<int> lstIntD(lstIntA);                        //1 3 5 7 9
list的赋值
    list.assign(beg,end);    //将[beg, end)区间中的数据拷贝赋值给本身。注意该区间是左闭右开的区间。
    list.assign(n,elem);  //将n个elem拷贝赋值给本身。
    list& operator=(const list &lst);    //重载等号操作符
    list.swap(lst);  // 将lst与本身的元素互换。

    list<int> lstIntA,lstIntB,lstIntC,lstIntD;
    lstIntA.push_back(1);
    lstIntA.push_back(3);
    lstIntA.push_back(5);
    lstIntA.push_back(7);
    lstIntA.push_back(9);

    lstIntB.assign(lstIntA.begin(),lstIntA.end());        //1 3 5 7 9
    lstIntC.assign(5,8);                            //8 8 8 8 8
    lstIntD = lstIntA;                            //1 3 5 7 9
    lstIntC.swap(lstIntD);                        //互换
list的大小
    list.size();       //返回容器中元素的个数
    list.empty();       //判断容器是否为空
    list.resize(num);   //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
    list.resize(num, elem);  //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。

    list<int> lstIntA;
    lstIntA.push_back(1);
    lstIntA.push_back(3);
    lstIntA.push_back(5);

    if (!lstIntA.empty())
    {
        int iSize = lstIntA.size();        //3
        lstIntA.resize(5);            //1 3 5 0 0
        lstIntA.resize(7,1);            //1 3 5 0 0 1 1
        lstIntA.resize(2);            //1 3
    }
list的插入
    list.insert(pos,elem);   //在pos位置插入一个elem元素的拷贝，返回新数据的位置。
    list.insert(pos,n,elem);   //在pos位置插入n个elem数据，无返回值。
    list.insert(pos,beg,end);   //在pos位置插入[beg,end)区间的数据，无返回值。

    list<int> lstA;
    list<int> lstB;

    lstA.push_back(1);
    lstA.push_back(3);
    lstA.push_back(5);
    lstA.push_back(7);
    lstA.push_back(9);

    lstB.push_back(2);
    lstB.push_back(4);
    lstB.push_back(6);
    lstB.push_back(8);

    lstA.insert(lstA.begin(), 11);        //{11, 1, 3, 5, 7, 9}
    lstA.insert(++lstA.begin(),2,33);        //{11,33,33,1,3,5,7,9}
    lstA.insert(lstA.begin() , lstB.begin() , lstB.end() );    //{2,4,6,8,11,33,33,1,3,5,7,9}
list的删除
    list.clear();        //移除容器的所有数据
    list.erase(beg,end);  //删除[beg,end)区间的数据，返回下一个数据的位置。
    list.erase(pos);    //删除pos位置的数据，返回下一个数据的位置。
    lst.remove(elem);   //删除容器中所有与elem值匹配的元素。

删除区间内的元素
lstInt是用list<int>声明的容器，现已包含按顺序的1,3,5,6,9元素。
list<int>::iterator itBegin=lstInt.begin();
++ itBegin;
list<int>::iterator itEnd=lstInt.begin();
++ itEnd;
++ itEnd;
++ itEnd;
lstInt.erase(itBegin,itEnd);
//此时容器lstInt包含按顺序的1,6,9三个元素。



假设 lstInt 包含1,3,2,3,3,3,4,3,5,3，删除容器中等于3的元素的方法一
for(list<int>::iterator it=lstInt.being(); it!=lstInt.end(); )    //小括号里不需写  ++it
{
   if(*it == 3)
   {
        it  =  lstInt.erase(it);       //以迭代器为参数，删除元素3，并把数据删除后的下一个元素位置返回给迭代器。
         //此时，不执行  ++it；  
   }
   else
   {
       ++it;
   }
}

删除容器中等于3的元素的方法二
lstInt.remove(3);

删除lstInt的所有元素
lstInt.clear();            //容器为空
list的反序排列
    lst.reverse();     //反转链表，比如lst包含1,3,5元素，运行此方法后，lst就包含5,3,1元素。

    list<int> lstA;
    
    lstA.push_back(1);
    lstA.push_back(3);
    lstA.push_back(5);
    lstA.push_back(7);
    lstA.push_back(9);

    lstA.reverse();            //9 7 5 3 1

二：List的源码 （转:http://blog.csdn.net/terence1212/article/details/52302501）

List的节点结构如下：

template <class T>
struct __list_node
{
  typedef void* void_pointer; 
  void_pointer next;    //型别为void*，也可以设为__list_node<T>*
  void_pointer prev;
  T data;
};
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

从节点结构可以看出，List就是一个双向链表


在Vector中，由于是连续的存储空间，支持随机存取，所以其迭代器可以直接用普通指针代替。但是，在List中行不通。List必须有能力指向List的节点，并有能力进行正确的递增、递减、取值和成员存取等操作。

List是一个双向链表，迭代器必须具备前移、后退的能力，所以List的迭代器是一个Bidirectional Iterator！在Vector中如果进行插入和删除操作后迭代器会失效，List有一个重要的性质就是插入和接合操作都不会造成原有的List迭代器失效。而且，再删除一个节点时，也仅有指向被删除元素的那个迭代器失效，其他迭代器不受任何影响。下面来看看List迭代器的源码。

template<class T, class Ref, class Ptr>
struct __list_iterator
{
  typedef __list_iterator<T, T&, T*>             iterator;   // 支持Iterator_traits
  typedef __list_iterator<T, const T&, const T*> const_iterator;
  typedef __list_iterator<T, Ref, Ptr>           self;

    // 以下为支持Iterator_traits而定义的一些类型
  typedef bidirectional_iterator_tag iterator_category; //List的迭代器类型为双向迭代器
  typedef T value_type;                                
  typedef Ptr pointer;    
  typedef Ref reference;                                
  typedef size_t size_type;
  typedef ptrdiff_t difference_type;

  typedef __list_node<T>* link_type;                     

  // 这个是迭代器实际管理的资源指针
  link_type node;

  // 迭代器构造函数
  __list_iterator(link_type x) : node(x) {}
  __list_iterator() {}
  __list_iterator(const iterator& x) : node(x.node) {}

  // 在STL算法中需要迭代器提供支持
  bool operator==(const self& x) const { return node == x.node; }
  bool operator!=(const self& x) const { return node != x.node; }

  // 重载operator *, 返回实际维护的数据
  reference operator*() const { return (*node).data; }

  // 成员调用操作符
  pointer operator->() const { return &(operator*()); }

  // 前缀自加
  self& operator++()
  {
    node = (link_type)((*node).next);
    return *this;
  }

  // 后缀自加, 需要先产生自身的一个副本, 然会再对自身操作, 最后返回副本
  self operator++(int)
  {
    self tmp = *this;
    ++*this;
    return tmp;
  }

  self& operator--()
  {
    node = (link_type)((*node).prev);
    return *this;
  }

  self operator--(int)
  {
    self tmp = *this;
    --*this;
    return tmp;
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63

List的迭代器实现了==,!=,++,–,取值和成员调用等操作，由于是存放在不连续的内存空间，所以并不支持vector那样的p+n的操作。

List的数据结构

List的数据结构个List的节点数据结构是分开定义的，SGI的List不仅是一个双向链表，而且还是一个环状双向链表，所以它只需要一个指针，就能完整表现一个链表。

template <class T, class Alloc = alloc>
class list
{
protected:
  typedef void* void_pointer;
  typedef __list_node<T> list_node;

  // 这个提供STL标准的allocator接口
  typedef simple_alloc<list_node, Alloc> list_node_allocator;

  // 链表的头结点，并不存放数据
  link_type node;

  //....以下还有一堆List的操作函数
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

List构造函数

List提供了一个空构造函数，如下：

list() { empty_initialize(); }

// 用于空链表的建立
void empty_initialize()
{
  node = get_node();
  node->next = node;  // 前置节点指向自己
  node->prev = node;  // 后置节点指向自己
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

另外，List还提供了带参的构造函数，支持如下初始化操作：

List<int> myList(5,1); // 初始化5个1的链表，{1,1,1,1,1}
  • 1

其构造函数源码如下：

// 带参构造函数
list(size_type n, const T& value) { fill_initialize(n, value); }

// 创建值为value共n个结点的链表
void fill_initialize(size_type n, const T& value)
{
  empty_initialize();  // 先创建一个空链表
  insert(begin(), n, value); // 插入n个值为value的节点
}

// 在指定位置插入n个值为x的节点
void insert(iterator pos, int n, const T& x)
{
  insert(pos, (size_type)n, x);
}

// 在position前插入n个值为x的元素
template <class T, class Alloc>
void list<T, Alloc>::insert(iterator position, size_type n, const T& x)
{
  for ( ; n > 0; --n)
    insert(position, x);
}

// 好吧，到这里才是真正的插入操作
// 很简单的双向链表插入操作
iterator insert(iterator position, const T& x)
{
  link_type tmp = create_node(x);
  tmp->next = position.node;
  tmp->prev = position.node->prev;
  (link_type(position.node->prev))->next = tmp;
  position.node->prev = tmp;
  return tmp;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35

STL的List提供了很多种构造函数，此处我列举了其中一个，以此为例。

List的其他操作函数

get_node

此函数用来配置一个节点。

// 配置一个节点并返回
link_type get_node() { 
    return list_node_allocator::allocate(); 
}
  • 1
  • 2
  • 3
  • 4

put_node

此函数用来释放一个节点。

// 释放指定结点, 不进行析构, 析构交给全局的destroy,
void put_node(link_type p) {
    list_node_allocator::deallocate(p); 
}
  • 1
  • 2
  • 3
  • 4

create_node

此函数用来配置并构造一个节点，并初始化其值

// 配置一个节点，并初始化其值为x
link_type create_node(const T& x)
{
  link_type p = get_node();
  construct(&p->data, x);   //全局函数
  return p;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

destory_node

此函数用来析构一个节点。

// 析构结点元素, 并释放内存
void destroy_node(link_type p)
{
    destroy(&p->data);  //全局函数
    put_node(p);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

insert

此函数用来在制定位置插入一个节点(上面提到过这个函数，这里重复一下，List的主要插入工作都交给这个函数)，该函数是一个重载函数，其有多种形式。

// 好吧，到这里才是真正的插入操作
// 很简单的双向链表插入操作
iterator insert(iterator position, const T& x)
{
  link_type tmp = create_node(x);
  tmp->next = position.node;
  tmp->prev = position.node->prev;
  (link_type(position.node->prev))->next = tmp;
  position.node->prev = tmp;
  return tmp;
}
// 其还有如下多种形式的重载函数
// 在[first,last]区间内插入元素
template <class T, class Alloc> template <class InputIterator>
void list<T, Alloc>::insert(iterator position,
                            InputIterator first, InputIterator last)
{
  for ( ; first != last; ++first)
    insert(position, *first);
}
// 在position位置插入元素，元素调用该型别默认构造函数
iterator insert(iterator position) { return insert(position, T()); }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

push_back

在尾部插入元素，有了上面的insert函数之后，push_back就比较容易实现了。

// 在链表最后插入结点
void push_back(const T& x) { insert(end(), x); }
  • 1
  • 2

pop_front

// 在链表前端插入结点
void push_front(const T& x) { insert(begin(), x); }
  • 1
  • 2

earse

移除迭代器所指的元素

// 擦除指定结点
iterator erase(iterator position)
{
    // 双向链表移除节点的操作
    link_type next_node = link_type(position.node->next);
    link_type prev_node = link_type(position.node->prev);
    prev_node->next = next_node;
    next_node->prev = prev_node;
    destroy_node(position.node);
    return iterator(next_node);
}

// 上述函数还有一个重载版本，移除区间内所有的节点
// 擦除[first, last)间的结点
template <class T, class Alloc>
list<T, Alloc>::iterator list<T, Alloc>::erase(iterator first, iterator last)
{
    while (first != last) erase(first++);
    return last;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

pop_front

移除头节点元素，有了上述的erase函数，就很方便的实现了。

// 删除链表第一个结点
void pop_front() { erase(begin()); }
  • 1
  • 2

pop_back

移除链表中最后一个元素

// 删除链表最后一个结点
void pop_back()
{
    iterator tmp = end();
    erase(--tmp);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

clear

清除链表中的所有节点，也就是一个一个的清除

// 销毁所有结点, 将链表置空
template <class T, class Alloc>
void list<T, Alloc>::clear()
{
  link_type cur = (link_type) node->next;
  while (cur != node) { //遍历每一个节点
    link_type tmp = cur;
    cur = (link_type) cur->next;
    destroy_node(tmp);
  }
  node->next = node;// 移除后注意要保持链表是一个循环链表
  node->prev = node;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

remove

将链表中值为value的节点移除

// 移除特定值的所有结点
// 时间复杂度O(n)
template <class T, class Alloc>
void list<T, Alloc>::remove(const T& value)
{
    iterator first = begin();
    iterator last = end();
    while (first != last) { //保证链表非空
        iterator next = first;
        ++next;
        if (*first == value) erase(first);  //擦除该节点
        first = next;
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

transfer

将某段连续范围内的元素迁移到指定位置。（非公开接口）

void transfer(iterator position, iterator first, iterator last)
{
    if (position != last)
    {
        (*(link_type((*last.node).prev))).next = position.node;
        (*(link_type((*first.node).prev))).next = last.node;
        (*(link_type((*position.node).prev))).next = first.node;
        link_type tmp = link_type((*position.node).prev);
        (*position.node).prev = (*last.node).prev;
        (*last.node).prev = (*first.node).prev;
        (*first.node).prev = tmp;
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

这里借用侯捷先生的《STL源码剖析》中的一幅图来说明这个过程。

Transfer函数

splice

List提供的接合函数是Splice，上述transfer是非公开的函数。splice函数有如下几个版本:

// 将链表x移动到position之前
void splice(iterator position, list& x)
{
    if (!x.empty())
        transfer(position, x.begin(), x.end()); //仅仅调用了transfer函数
}

// 将链表中i指向的内容移动到position之前
void splice(iterator position, list&, iterator i)
{
    iterator j = i;
    ++j;
    if (position == i || position == j) return;
    transfer(position, i, j);
}

// 将[first, last}元素移动到position之前
void splice(iterator position, list&, iterator first, iterator last)
{
    if (first != last)
        transfer(position, first, last);
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

merge

此函数用来合并两个链表，这里两个链表必须是已拍好序的。

// 假设当前容器和x都已序, 保证两容器合并后仍然有序
template <class T, class Alloc>
void list<T, Alloc>::merge(list<T, Alloc>& x)
{
  iterator first1 = begin();
  iterator last1 = end();
  iterator first2 = x.begin();
  iterator last2 = x.end();
  while (first1 != last1 && first2 != last2)
    if (*first2 < *first1) {
      iterator next = first2;
      transfer(first1, first2, ++next); //将first2节点迁移到first1之后
      first2 = next;
    }
    else
      ++first1;
  if (first2 != last2) transfer(last1, first2, last2);  //如果first2还有剩余的，直接接合再链表1尾部
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

reverse

此函数用来反转链表，其具体实现如下：

// 将链表倒置
template <class T, class Alloc>
void list<T, Alloc>::reverse()
{
  if (node->next == node || link_type(node->next)->next == node) return;
  iterator first = begin();
  ++first;
  while (first != end()) {
    iterator old = first;   // 取出一个节点
    ++first;
    transfer(begin(), old, first);  // 插入到begin()之后
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

sort

此函数对链表进行升序排序，具体实现如下：

// 按照升序排序
template <class T, class Alloc>
void list<T, Alloc>::sort()
{
  if (node->next == node || link_type(node->next)->next == node) return;
  list<T, Alloc> carry;
  list<T, Alloc> counter[64];
  int fill = 0;
  while (!empty()) {
    // 从链表中取出一个节点
    carry.splice(carry.begin(), *this, begin());
    int i = 0;
    // 把carry中的新元素和counter中的结果逐一进行归并
    while (i < fill && !counter[i].empty()) {
      counter[i].merge(carry);
      carry.swap(counter[i++]);
    }
    // 把归并后的结果存放在counter[i]中
    carry.swap(counter[i]);
    // 已经达到2*fill，fill自增1
    if (i == fill) ++fill;
  }
  // 将counter中的所有元素进行归并
  for (int i = 1; i < fill; ++i) counter[i].merge(counter[i - 1]);
  // 将counter链表和本链表进行交换
  swap(counter[fill - 1]);
}

// 交换本链表和链表x
void swap(list<T, Alloc>& x) { 
    swap(node, x.node); 
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32

这里可以举个例子来说明一下这个过程：(以链表5,3,6,4,7,9,1,2,8)

carry每次从数组中取一个数，然后归并到counter数组中，该算法最多只能排序2的64次方个数。


Ym影子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++ PPT第9章 标准模板库STL.ppt
05-30
C++标准模板库（Standard Template Library，简称STL）是C++语言中的一种通用库，主要思想是结合C++的模板机制，设计出一系列针对数据结构中具体问题的类模板和函数模板，并不针对具体的数据类型，形成了具有优秀、...
C++模板与STL库介绍
03-18
这个模板函数可以应用于任何具有迭代器接口的容器，如`std::vector<int>`、`std::list<double>`等。 此外，STL还提供了算法如`std::transform`，可以配合模板函数，将一个容器中的元素转换为另一种形式： ```cpp ...
STL中list的详细解析
m0_69005269的博客
01-28 600
list详细全解！！
STL-list容器
一亩三分地儿
09-23 559
1. list容器基本概念 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相较于vector的连续线性空间，list就显得负责许多，它的好处是每次插入或者删除一个元素，就是配置
标准模板库STL(Standard Template Library)
never give up的博客
10-20 1246
标准模板库STL(Standard Template Library)
【C++初阶】第七站：string类的初识(万字详解、细节拉满)
最新发布
weixin_65186652的博客
03-19 4142
一、什么是STL 二、STL的六大组件 三、STL的缺陷 四、为什么学习string类? 五、标准库中的string类
C++标准模板库(STL)(1) 之 string类 (自学笔记)
jnxhz2008的博客
07-30 459
持续更新中... 目录 前言 一、string类 头文件 二、string和字符数组简单对比 2.1 定义 2.2 赋值 2.3 附加 2.4 长度 三、string类的构造函数 3.1 string(const char *s) 3.2 string(size_type n, char c) 3.3 string(const string &str) 3.4 string() 3.5 string(const char *s, size_...
学习笔记：C++初阶【C++入门、类和对象、C/C++内存管理、模板初阶、STL简介、string、vector、list、stack、queueu、模板进阶、C++的IO流】
qq_45743853的博客
09-03 2043
这篇是学习笔记：记录C++入门到进阶再到高阶数据结构学习过程中的要点疑点和难点。笔记简介：这篇笔记写于2022/09/03。
《STL源码剖析》随笔
qq_43082206的博客
02-10 138
STL源码剖析随笔第二章 空间配置器第三章 迭代器与traits 第二章 空间配置器   内存分配过程     STL的内存分配分为两级。     第一级是在所需分配内存大于128字节时。       此时只使用malloc分配内存，当malloc无法取得有效内存时，则会调用名为’内存不足处理例程’，调用该函数后依旧无法成功取得内存，就抛出异常。     第二级是在所需分配内存小于128字节时。       第二级则是为了解决内存碎片问题。其维护16个自由链表，分别是 8~128字节中8的倍数，这些内存被初
第一篇：C/C++语法与std数据结构
qq_35635374的博客
11-07 784
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 TODO:写完再整理 文章目录系列文章目录前言一、C++在C基础上的改进1.C语言和C++语言的关系2.C++的开发工具3.面向对象的思想4.面向过程和面向对象的两种思维比喻5.面向对象思想的的特点6.C/C++的特点（1）C++特点：（2）使用面向对象的编程技术开发程序的基本步骤：（3）面向对象的优点（4）高级的面向对象编程方法（5）解决程序的阻塞性二、C++的数据结构【重要】1.布尔型bool2.整型int(int_16、
【C++初阶：STL —— string】string类 | 浅拷贝和深拷贝(传统写法和现代写法) | string类的模拟实现
wh128341的博客
03-29 2420
到这里我们就要学会能自己能看文档了，因为就这个 string 类来说就有一百多个接口函数，那肯定记不住呀，我们平时用的大概就二十个，一般我们都是学习它比较常用的，其它的大概熟悉它们有哪些功能，真要用到时再去查文档。可以看到其实 string 就是一个管理字符数组的顺序表，因为字符数组的使用广泛，C++ 就专门给了一个 string 类，由于编码原因，它写的是一个模板。针对 string，一般情况它有三个成员 —— char* _str、size_t _size、size_t _capacity，我们在下面模
STL标准模板库
11-08
C++ STL 向量vector是一种随机访问的数组类型，提供了对数组元素的快速、随机访问以及在序列尾部快速、随机的插入和删除操作。它是大小可变的向量，在需要是可以改变其大小。 形式：
STL 模板库 第五日 ： vector的使用
阿呆的隐秘角落
02-19 311
STL 模板库    vector一：什么是vector  vector(向量):是一种顺序容器，事实上和数组差不多，但它比数组更优越。一般来说数组不能动态拓展，因此在程序运行的时候不是浪费内存，就是造成越界。而vector正好弥补了这个缺陷，它的特征是相当于可分配拓展的数组，它的随机访问快，在中间插入和删除慢，但在末端插入和删除快。 二：vector的本质是什么vector 是一个动态数组，它可...
STL 模板库 第六日 ： deque
阿呆的隐秘角落
02-19 306
STL 模板库 deque一：什么是deque所谓的deque是”double ended queue”的缩写，双端队列不论在尾部或头部插入元素，都十分迅速。而在中间插入元素则会比较费时，因为必须移动中间其他的元素。双端队列是一种随机访问的数据类型，提供了在序列两端快速插入和删除操作的功能，它可以在需要的时候改变自身大小，完成了标准的C++数据结构中队列的所有功能。Vector是单向开口的连续线性...
STL 模板库第八日 ： set与multiset
阿呆的隐秘角落
02-20 235
set 容器前言：什么是set容器？map容器是键-值对的集合，好比以任命为键的地址和电话号码。而set容器只是单纯的键的集合。当只想知道一个值是否存在时，使用set容器是最适合。使用set容器必须包含set头文件：#include &lt;set&gt;set容器支持大部分map操作，包括：    关联容器中通用的操作。    三种构造函数。    insert操作。    count和find...
STL 模板库第四日 ：玩转 string
阿呆的隐秘角落
02-18 209
前言：C中是没有string这个类的（或者说就没有类的概念），C++ STL中提供了关于字符串操作的一系列操作，包括定义初始化，字符串算法，迭代器等等的一系列内容。下面是自己实现的一个简单的string类：#include &lt;iostream&gt; #include &lt;cstring&gt; using namespace std; class String{ public: ...
STL模板库实战教程：从基础到进阶
"STL模板库实用例子大全" 这篇文章是一份全面的STL（Standard Template Library，标准模板库）实例教程，特别适合初学者学习。它详细地展示了STL中的各个组件，通过编程实例来帮助理解每个函数的工作原理和用法。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Ym影子

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值