标签：直接 计算机科学 释放 固定 地址 不同 begin else 分区
STL（Standard Template Library），即标准模板库，是一个高效的C++程序库。包含了诸多在计算机科学领域里常用的基本数据结构和基本算法。为广大C++程序员们提供了一个可扩展的应用框架，高度体现了软件的可复用性。其核心思想就是泛化编程（generic programming），在这种思想里，大部分基本算法被抽象，被泛化，独立于与之对应的数据结构，用于以相同或相近的方式处理各种不同情形。
STL中包含了6大组件
Containers 通过 Allocators 取得数据存储空间，Algorithms 通过 Iterators 存取 Containers 内容，Functors 可以协助 Algorithms 完成不同的策略变，Adapters 可以修饰或套接Containers，Iterators和Functors。
容器总体上分为三大类：
是一种固定大小的容器类型，在定义的时候就要声明大小和类型。Array其实就是对C语言中数组的一种扩充升级，使其支持了迭代器的操作，便于STL算法的使用。array在使用和性能上都要强于内置数组，对于一些固定大小的使用场景，可以用array来替代原先数组的工作。
TR1版本源码如下：
template<typename _Tp, std::size_t _Nm>
struct array
{
typedef _Tp value_type;
typedef _Tp* pointer;
typedef balue_type* iterator;
value_type _M_instance[_Nm ? _Nm : 1];
iterator begin()
{ return iterator(&_M_instance[0]);}
iterator end()
{ return iteratoe(&_M_instance[_Nm]);}
...
}Vector 使用起来和一个数组十分相似，但是在空间用完时，可以自动扩充自己的空间。一般而言空间的扩充，无法在原地完成扩充。所以会在内存中新申请一片内存（通常都是之前空间大小的2倍大），然后通过拷贝将原有数据拷贝到新的地址空间。
Vector中存在三个指针来表明Vector：
需要注意的是：在空间（两倍）增长的过程中涉及到了大量的拷贝构造和析构！
相较于vector的连续线性空间，List就显得复杂许多，它的好处是每次插入或删除一个元素，就配置或释放一个元素空间。因此，list对于空间的运用有绝对的精准，一点也不浪费。而且，对于任何位置的元素插入或元素移除，List永远是常数时间。
List不仅是一个双向链表，而且还是一个环状双向链表。 另外，还有一个重要性质，插入操作和接合操作都不会造成原有的List迭代器失效，这在Vector是不成立的。因为Vector的插入操作可能造成空间的重新配置，导致原有的迭代器全部失效。甚至List的元素删除操作（erase），也只有“指向被删除元素”的那个迭代器失效，其他迭代器不受任何影响。
Forward-List容器与List容器的主要设计区别是List保持内部唯一的一个链接到下一个元素，而后者则保持每个元素的两个链接：一个指向下一个元素和一个前一个。允许高效在两个方向迭代，但每个元素的消耗额外的存储空间，并轻微较高的时间开销插入和删除元素的迭代。Forward-List对象，从而比List对象更有效率，虽然他们只能向前遍历。
所以Forward-List的一个最大的缺点就是无法直接访问指定位置上元素，每次一的访问都需要从头开始访问，这样的操作需要线型的时间。
可以向两端扩充，通过指针连接不同分段的空间，模拟出连续空间。
template <class T, class Alloc=alloc, size_t BufSiz=0>
class deque{
public:
typedef T value_type;
typedef __deque_iterator<T,T&,T*,BufSiz> iterator;
protected:
typedef pointer* map_pointer;//T**
protected:
iterator start;
iterator finish;
map_pointer map;
size_type map_size;
public:
iterator begin(){return start;}
iterator end(){return finish;}
size_type size(){return finish-start;}
...
}
template <class T, class Ref, class Ptr, size_t BufSiz>
struct __deque_iterator{
typedef random_access_iterator_tag iterator_category;
typedef T value_type;
typedef Ptr pointer;
typedef Ref reference;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef T** map_pointer;
typedef __deque_iterator self;
T* cur;
T* first;
T* last;
map_pointer node;
...
}start指向第一块分区，finishi指向最后一块分区，map是用来存放各个分区的地址（vector实现），map_size是map的大小。
start和finish作为iterator，cur指向当前的元素，first指向第一个存放的元素，last指向当前分区中最后一个存放的数据之后的位置，node指回map。
deque 如何模拟连续空间？
基本全部依靠deque iterators完成
reference operator*() const
{
return *cur;
}
pointer operator->() const
{
return &(operator*());
}
difference_type operator-(const self& x) const
{
return difference_type(buff_size()) * (node - x.node - 1) + (cur - first) + (x.last - x.cur);
}
self& operator++(){
++cur;
if(cur == last){
set_node(node + 1);
cur = first;
}
return *this;
}
self operator++(int){
self tmp = *this;
++*this;
return tmp;
}
self& operator--(){
if(cur == first){
set_node(node - 1);
cur = last;
}
--cur;
return *this;
}
self operator--(int){
self tmp = *this;
--*this;
return tmp;
}
void set_node(map_pointer new_node){
node = new_node;
first = *new_node;
last = first + difference_type(buffer_size());
}
self& operator+=(difference_type n){
difference_type offset = n + (cur - first);
if(offset >= 0 && offset < difference_type(buffer_size())){
cur += n;
}
else{
difference_type node_offset = offset > 0 ? offset / difference_type(buffer_size()) : -difference_type((-offset - 1) / buffer_size()) - 1;
set_node(node + node_offset);
cur = first + (offset - node_offset * difference_type(buffer_size()));
}
return * this;
}
self operator+(difference_type n) const {
self tmp = *thisl
return tmp +=n;
}
self& operator-=(fifference_type n)
{
return *this += -n;
}
self operator-(difference_type n) const
{
self tmp = * this;
return tmp -= n;
}
reference operator[](difference_type n) const
{
return *(*this + n);
}标签：直接 计算机科学 释放 固定 地址 不同 begin else 分区
原文地址：https://www.cnblogs.com/joker-wz/p/10234860.html
