STL剖析:从capacity()和resize()看容器的内存分配思想

本文探讨了一个关于C++ STL容器中vector的有趣问题,解释了如何正确使用reserve和resize函数来预分配内存和调整容器大小,避免迭代器指向问题。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

这个blog来源于一个朋友提出的的问题
  下面的代码想输出0-9,可不行。原因是iterStart居然等于iterEnd,为什么?
  list<int> li;
  vector<int> vi;
  for(int c=0;c<10;c++) li.push_back(c);
  vi.reserve(li.size());
  copy(li.begin(),li.end(),vi.begin());
  vector<int>::iterator iterStart=vi.begin();
  vector<int>::iterator iterEnd=vi.end();
  vector<int>::iterator it=iterStart;
  for(;it!=iterEnd;it++)
  {
   cout<<*it<<endl;
  }
  ---------------------------------------------------------
  有趣的问题,2种解决方案:
  1)把
  vi.reserve(li.size());
  修改为
  vi.resize(li.size());
  2)在构造时指定空间
  vector<int> vi(li.size())
  问题在于对reserve()函数的理解:
  下面是reserve()的MSDN帮助:
  vector::reserve
  void reserve(size_type n);
  The member function ensures that capacity() henceforth returns at least n.
  下面是resize()的MSDN帮助:
  vector::resize
  void resize(size_type n, T x = T());
   The member function ensures that size() henceforth returns n. If it must lengthen the controlled sequence, it appends elements with value x.
  关键在于:reserve()已经分配了空间,但是“不可以使用”!考虑以下的使用场景:
  Step1:现在大小是10(size()和capacity()返回10),保留1000个元素的空间(使用reserve()),说明以后1000个元素的空间已经分配成功了,但是size()仍然返回10,capacity()返回1000!
  Step2:调用resize(100),实际没有重新分配空间(因为已经“分配并保留”了1000)。此时size()返回100, capacity()返回1000!
  A little deeper:查看STL的源代码会更容易的理解这个问题。列出vector的size()和capacity()函数的实现:
  size_type size() const
   {return (_First == 0 ? 0 : _Last - _First); }
  size_type capacity() const
   {return (_First == 0 ? 0 : _End - _First); }
  注意:size()使用了_Last指针,而capacity()使用了_End指针!
  Aha!原来所谓的“尾指针”有2个:
  _Last表示真正的数据(允许使用的空间)的尾指针;
  _End表示已经分配的空间的尾指针;
   这个问题的根本还是对于STL容器的内存分配方式的理解,i.e. reserve()和resize()的区别。如果没有提供reserve()方法,相信会更加容易理解,代价是失去了更好的内存管理的手段。提供 reserve()方法的目的,我理解是允许用户使用memory pool的思想来手动控制内存的分配,即预先保留足够多的空间(由_End控制),然后根据需要使用实际的内存空间(由_Last控制)

### STL 源码剖析与 C++ 标准模板库实现详解 #### 1. **STL 的核心组成** C++ 标准模板库(STL)主要由四个部分构成:容器、迭代器、算法仿函数。这些组件共同协作,实现了高效的数据管理操作功能[^1]。 - **容器** 是用来存储数据的对象集合,包括顺序容器(`vector`, `list`, `deque`)、关联容器(`set`, `map`, `unordered_set`, `unordered_map`)等。 - **迭代器** 提供了一种统一的方式来访问容器中的元素,屏蔽了不同容器的具体细节。 - **算法** 则封装了许多常用的计算模式,如查找、排序、复制等。 - **仿函数** 可以像普通函数那样被调用,但它们实际上是类的实例,允许携带状态信息。 #### 2. **STL 容器的内部实现** ##### (1)Vector 实现 `std::vector` 是一种动态数组形式的序列容器,支持随机存取。它的底层通常采用连续内存块来保存元素。当容量不足时,会重新分配一块更大的空间并将原内容搬移到新位置。这种扩容机制一般按照指数增长的方式进行,即每次增加一定比例的空间大小,从而摊销单次插入的时间复杂度至 O(1)[^1]。 以下是简单的 vector 扩展逻辑伪代码展示: ```cpp template<typename T> class SimpleVector { private: size_t m_size; size_t m_capacity; T* m_data; public: // 构造函数初始化成员变量 SimpleVector():m_size{0},m_capacity{8},m_data{(T*)malloc(sizeof(T)*8)}{} ~SimpleVector(){ free(m_data); } void push_back(const T& val){ if(m_size >= m_capacity){ resize(); } new(&m_data[m_size]) T(val); ++m_size; } private: void resize(){ auto old_cap=m_capacity; m_capacity *=2 ; T* newData=(T*)realloc(m_data,sizeof(T)*m_capacity); for(auto i=old_cap;i<m_capacity;++i){ newData[i].~T(); } m_data=newData; } }; ``` ##### (2)List 实现 `std::list` 是双向链表结构,每个节点包含前驱指针、后继指针以及自身的数据项。由于不依赖固定地址布局,因此可以在任意位置快速插入或删除节点,时间复杂度均为 O(1),不过随机访问效率较低,需逐一遍历找到目标索引处的节点[^4]。 下面给出 list 插入节点的一个简化版本: ```cpp template<class T> struct Node{ T data; Node<T>* prev,*next; }; template<class T> class SingleLinkedList{ protected: Node<T>* head; public: SingleLinkedList():head(nullptr){} void insert_front(const T& value){ Node<T>* newNode =new Node<T>{value,nullptr,head}; if(head!=nullptr) head->prev=newNode; head=newNode; } }; ``` ##### (3)Map/Unordered_Map 实现 对于有序映射 `std::map` 而言,大多基于红黑树这一平衡二叉搜索树变体构建而成;而无序哈希表则对应着 `std::unordered_map` 。前者能够保证键值对按键升序排列并维持稳定查询速度 logN ,后者借助散列函数定位槽位进而达到平均常量级别检索耗时 [^1]. 这里呈现 map 删除最小关键字的过程示意如下: ```cpp struct RBTreeNode{ bool color;//true表示红色 false黑色 int key; RBTreeNode *left,*right,*parent; }; RBTreeNode* minimum(RBTreeNode* node){ while(node &&node ->left != nullptr ){ node=node->left; } return node; } void transplant(RBTREE tree,RBTreeNode*u ,RBTreeNode*v){ if(u->parent==nullptr){ tree.root=v; }else if(u == u->parent->left){ u->parent->left=v; }else{ u->parent->right=v; } if(v!=nullptr){ v->parent=u->parent; } } RBTreeNode* delete_node(RBTREE tree,int z_key){ RBTreeNode*z=search(tree,z_key); RBTreeNode*y=z; RBTreeNode*x=nullptr; COLOR origin_color=y.color; if(z->left == nullptr){ x=z->right; transplant(tree,z,x); }else if(z->right == nullptr){ x=z->left; transplant(tree,z,x); }else{ y=minimum(z->right); origin_color=y.color; x=y->right; if(y->parent ==z){ x->parent=y; }else{ transplant(tree,y,y->right); y->right=z->right; y->right->parent=y; } transplant(tree,z,y); y->left=z->left; y->left->parent=y; y->color=z->color; } if(origin_color ==BLACK){ fix_delete_violation(tree,x); } return z; } ``` #### 3. **STL 迭代器的工作原理** 迭代器是一种抽象接口,使得我们可以一致地遍历各种类型的容器。根据行为特性可分为五种类别:输入迭代器、输出迭代器、前向迭代器、双向迭代器随机访问迭代器[^1]。其中最高级别的随机访问迭代器具备最丰富的操作集,能执行加减偏移量、比较两个迭代器相对距离等功能。 例如针对 vector 创建相应范围内的逆序读取适配器: ```cpp auto it_begin = rbegin(vector_instance); auto it_end = rend(vector_instance); while(it_begin !=it_end){ process(*it_begin++); } ``` #### 4. **总结** 通过对 STL 各模块深入探究可知,其背后蕴含诸多精妙设计理念技术手段。无论是灵活多样的容器还是强大通用性的算法工具箱,都极大地方便了日常开发任务的同时也提升了软件质量水平。然而值得注意的是,在追求高性能表现的时候也要兼顾具体应用场景需求合理选用合适的技术方案[^5]。
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

打赏作者

do2jiang

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

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

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

打赏作者

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

抵扣说明:

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

余额充值