STL 源码剖析读书笔记一：空间配置器

最新推荐文章于 2019-07-29 18:21:18 发布
最新推荐文章于 2019-07-29 18:21:18 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： STL 源码剖析 文章标签： SGI-STL 空间配置器 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fool_duck/article/details/51313185
版权

1. STL 的空间配置器

STL 空间配置器在运用的角度来说，是最不需要介绍的，它总是隐藏在一切组件背后。但若以 STL 的实现角度而言，第一个需要理解的就是空间配置器。

根据 STL 规范，以下是 allocator 的必要接口：

allocator::value_type
allocator::pointer
allocator::const_pointer
allocator::reference
allocator::const_reference
allocator::size_type
allocator::difference_type

//一个嵌套的class template.class rebind<U>拥有唯一成员other，那allocator::allocator()
allocator::rebind 

//default constructor
allocator::allocator() 

//copy constructor
allocator::allocator(const allocator &) 

//泛化的copy constructor
template<class U>
allocator::allocator(const allocator<U> &) 

//destructor
allocator::~allocator() 

//返回某个对象的地址。算式a.address(x)等同于&x
pointer allocator::address(reference x) const 

//返回某个const对象的地址。算式a.address(x)等同于&x
const_pointer allocator::address(const_referenc x) const 

//配置空间，足以存储n个T对象。第二参数是个提示。实现上可能会利用它来增进区域性，或完全忽略之。
pointer allocator::allocate(size_type n ,const void * = 0 ) 

//归还先前配置的空间
void allocator::deallocate(pointer p ,size_type n)

//返回可成功配置的最大量
size_type allocator::max_size() const

//等同于new((void *)p) T(x)
void allocator::construct(pointer p ,const T& x) 

//等同于p->~T()
void allocator::destory(pointer p)</span>

2. 具备次配置力的 SGI 空间配置器

SGI 的配置器与众不同，也与标准规范不同，其名称是 alloc，而不是 allocator，而且不接受任何参数。SGI 也有定义一个符合部分标准、名为 allocator 的配置器，但 SGI 自己从未用过它，也不建议我们使用，主要原因是效率不佳，只是对 ::operator new 和 ::operator delete 的简单包装。

为了精密分工，STL allocator 决定将 内存配置/释放 和对象构造/析构 两个阶段的操作区分开来，分别由如下函数来实现：

alloc::allocator()          //内存配置
alloc::deallocator()        //内存配置

::construcct()              //对象构造
::destroy()                 //对象析构

这里写图片描述

2.1 构造和析构基本工具：construct() 和 destroy()

以下是construct() 和 destroy()的实现：


#ifndef __SGI_STL_INTERNAL_CONSTRUCT_H
#define __SGI_STL_INTERNAL_CONSTRUCT_H

#include <new.h>

__STL_BEGIN_NAMESPACE

// 使用 placement new 构造对象，调用构造函数 T1::T1(value);
template <class T1, class T2>
inline void construct(T1* p, const T2& value) {
  new (p) T1(value);
}

// 接受一个指针的 destroy 函数
template <class T>
inline void destroy(T* pointer) {
    pointer->~T();
}

// 接受两个迭代器，使用 value_type() 获得迭代器所指对象的数值型别
template <class ForwardIterator>
inline void destroy(ForwardIterator first, ForwardIterator last) {
  __destroy(first, last, value_type(first));
}

// 使用 __type_traits<> 判断该类型析构函数是否为 trivial
template <class ForwardIterator, class T>
inline void __destroy(ForwardIterator first, ForwardIterator last, T*) {
  typedef typename __type_traits<T>::has_trivial_destructor trivial_destructor;
  __destroy_aux(first, last, trivial_destructor());
}

// 对象析构函数为 trivial，什么都不用做
template <class ForwardIterator> 
inline void __destroy_aux(ForwardIterator, ForwardIterator, __true_type) {}

// 对象析构函数为 non-trivial，这时需要对迭代器范围内的每一个元素分别调用 destroy()
template <class ForwardIterator>
inline void
__destroy_aux(ForwardIterator first, ForwardIterator last, __false_type) {
  for ( ; first < last; ++first)
    destroy(&*first);
}

// destroy() 针对 char* 和 wchar* 的特化版
inline void destroy(char*, char*) {}
inline void destroy(wchar_t*, wchar_t*) {}

__STL_END_NAMESPACE

#endif /* __SGI_STL_INTERNAL_CONSTRUCT_H */
2.2 空间的配置与释放

对象构造前的空间配置和对象析构后的空间释放由 stl_alloc.h 负责，SGI 对此的设计哲学如下：

  • 向 system heap 要求空间
  • 考虑多线程状态
  • 考虑内存不足时的应变措施
  • 考虑过多“小型区块”可能造成的内存碎片（fragment）问题

alloc 配置内存和释放内存使用的是 malloc() 和 free()。
考虑到小型区块可能造成内存碎片问题，SGI 设计了双层配置器，第一级配置器直接使用 malloc 和 free，第二级配置器视情况不同采用不同的配置器：

  • 当配置区块超过128 byte 时，视为足够大，调用第一级配置器
  • 当配置区块小于128 byte 时，视为过小，采用内存池的方式配置内存

只开放第一级配置器还是同时开发第二级配置器取决于 __USE_MALLOC 是否被定义：

无论 alloc 被定义为哪一级配置器，SGI 再为它包装一个接口如下：

template<class T, class Alloc>
class simple_alloc {

public:
    static T *allocate(size_t n)
                { return 0 == n? 0 : (T*) Alloc::allocate(n * sizeof (T)); }
    static T *allocate(void)
                { return (T*) Alloc::allocate(sizeof (T)); }
    static void deallocate(T *p, size_t n)
                { if (0 != n) Alloc::deallocate(p, n * sizeof (T)); }
    static void deallocate(T *p)
                { Alloc::deallocate(p, sizeof (T)); }
};

两级配置器的关系：

这里写图片描述

SGI STL 容器全部使用这个 simple_alloc 接口，例如：

template <class T, class Alloc = alloc>
class vector {
public:
  typedef T value_type;
  typedef value_type* pointer;
  ...
  typedef simple_alloc<value_type, Alloc> data_allocator;
  iterator start;
  iterator finish;
  iterator end_of_storage;
  ...

  void deallocate() {
    if (start) data_allocator::deallocate(start, end_of_storage - start);
  }
2.3 第一级配置器 __malloc_alloc_template

template <int inst>
class __malloc_alloc_template {

private:
// 用于处理内存不足的情况
static void *oom_malloc(size_t);
static void *oom_realloc(void *, size_t);
#ifndef __STL_STATIC_TEMPLATE_MEMBER_BUG
    static void (* __malloc_alloc_oom_handler)();
#endif

public:

// 直接 malloc
static void * allocate(size_t n)
{
    void *result = malloc(n);
    if (0 == result) result = oom_malloc(n);
    return result;
}

// 直接 free
static void deallocate(void *p, size_t /* n */)
{
    free(p);
}

// 直接 realloc
static void * reallocate(void *p, size_t /* old_sz */, size_t new_sz)
{
    void * result = realloc(p, new_sz);
    if (0 == result) result = oom_realloc(p, new_sz);
    return result;
}

// 设置自己的 out-of-memory-handler
static void (* set_malloc_handler(void (*f)()))()
{
    void (* old)() = __malloc_alloc_oom_handler;
    __malloc_alloc_oom_handler = f;
    return(old);
}

};


// malloc_alloc out-of-memory handling

#ifndef __STL_STATIC_TEMPLATE_MEMBER_BUG
template <int inst>
void (* __malloc_alloc_template<inst>::__malloc_alloc_oom_handler)() = 0;
#endif

template <int inst>
void * __malloc_alloc_template<inst>::oom_malloc(size_t n)
{
    void (* my_malloc_handler)();
    void *result;

    for (;;) {         //不断尝试释放、配置、再释放、再配置
        my_malloc_handler = __malloc_alloc_oom_handler;
        if (0 == my_malloc_handler) { __THROW_BAD_ALLOC; }
        (*my_malloc_handler)();  // 调用处理例程，企图释放内存
        result = malloc(n);      // 再次尝试配置内存
        if (result) return(result);
    }
}

template <int inst>
void * __malloc_alloc_template<inst>::oom_realloc(void *p, size_t n)
{
    void (* my_malloc_handler)();
    void *result;

    for (;;) {         //不断尝试释放、配置、再释放、再配置
        my_malloc_handler = __malloc_alloc_oom_handler;
        if (0 == my_malloc_handler) { __THROW_BAD_ALLOC; }
        (*my_malloc_handler)();      // 调用处理例程，企图释放内存
        result = realloc(p, n);      // 再次尝试配置内存
        if (result) return(result);
    }
}

typedef __malloc_alloc_template<0> malloc_alloc;

第一级配置器的 allocate 和 realloc 都是在调用 malloc 和 realloc 不成功后，改调用 oom_malloc 和 oom_realloc，后两者都有内循环，不断调用内存不足处理例程，期望在某次调用后，获得足够内存而圆满完成任务。若内存不足处理例程未被设定，oom_malloc 和 oom_realloc 便调用 __THROW_BAD_ALLOC抛出 bad_alloc 异常或利用 exit(1) 中止程序。设计和设定内存不足处理例程都是客端的责任。

2.4 第二级配置器 __default_alloc_template
enum {__ALIGN = 8};
enum {__MAX_BYTES = 128};
enum {__NFREELISTS = __MAX_BYTES/__ALIGN};

template <bool threads, int inst>
class __default_alloc_template {
private:
  static size_t ROUND_UP(size_t bytes) {
        return (((bytes) + __ALIGN-1) & ~(__ALIGN - 1));
  }
private:
  union obj {
        union obj * free_list_link;
        char client_data[1];    /* The client sees this.        */
  };
private:
  static obj * __VOLATILE free_list[__NFREELISTS]; 
  static  size_t FREELIST_INDEX(size_t bytes) {
        return (((bytes) + __ALIGN-1)/__ALIGN - 1);
  }


  static void *refill(size_t n);
  static char *chunk_alloc(size_t size, int &nobjs);

  // 内存池
  static char *start_free;
  static char *end_free;
  static size_t heap_size;

public:

  /* n must be > 0      */
  static void * allocate(size_t n)
  {
    obj * __VOLATILE * my_free_list;
    obj * __RESTRICT result;

    if (n > (size_t) __MAX_BYTES) {
        return(malloc_alloc::allocate(n));
    }
    my_free_list = free_list + FREELIST_INDEX(n);
    result = *my_free_list;
    if (result == 0) {
        void *r = refill(ROUND_UP(n));
        return r;
    }
    *my_free_list = result -> free_list_link;
    return (result);
  };

  /* p may not be 0 */
  static void deallocate(void *p, size_t n)
  {
    obj *q = (obj *)p;
    obj * __VOLATILE * my_free_list;

    if (n > (size_t) __MAX_BYTES) {
        malloc_alloc::deallocate(p, n);
        return;
    }
    my_free_list = free_list + FREELIST_INDEX(n);
    q -> free_list_link = *my_free_list;
    *my_free_list = q;
  }

  static void * reallocate(void *p, size_t old_sz, size_t new_sz);

} ;

typedef __default_alloc_template<__NODE_ALLOCATOR_THREADS, 0> alloc;
typedef __default_alloc_template<false, 0> single_client_alloc;

// 注意：njobs是引用参数
template <bool threads, int inst>
char*
__default_alloc_template<threads, inst>::chunk_alloc(size_t size, int& nobjs)
{
    char * result;
    size_t total_bytes = size * nobjs;
    size_t bytes_left = end_free - start_free;

        if (bytes_left >= total_bytes) { // 内存池剩余空间完全满足需求量
        result = start_free;
        start_free += total_bytes;
        return(result);
    } else if (bytes_left >= size) {     // 内存池剩余空间不能完全满足需求量，但能提供一个（以上）的区块
        nobjs = bytes_left/size;
        total_bytes = size * nobjs;
        result = start_free;
        start_free += total_bytes;
        return(result);
    } else {                             // 内存池剩余空间一个区块都无法提供
        size_t bytes_to_get = 2 * total_bytes + ROUND_UP(heap_size >> 4);
        // Try to make use of the left-over piece.
        if (bytes_left > 0) {            // 将内存池的残余空间加入到 free_list
            obj * __VOLATILE * my_free_list =
                        free_list + FREELIST_INDEX(bytes_left);

            ((obj *)start_free) -> free_list_link = *my_free_list;
            *my_free_list = (obj *)start_free;
        }
        start_free = (char *)malloc(bytes_to_get); // 申请堆内存，补充内存池
        if (0 == start_free) {
            int i;
            obj * __VOLATILE * my_free_list, *p;

            for (i = size; i <= __MAX_BYTES; i += __ALIGN) {
                my_free_list = free_list + FREELIST_INDEX(i);
                p = *my_free_list;
                if (0 != p) {
                    *my_free_list = p -> free_list_link;
                    start_free = (char *)p;
                    end_free = start_free + i;
                    // 递归调用自己，修正 njobs 并返回
                    return(chunk_alloc(size, nobjs));
                    // 注意：任何残余零头终将被编入 free_list中备用
                }
            }
            end_free = 0;   // 出现意外，无内存可用
            start_free = (char *)malloc_alloc::allocate(bytes_to_get);
            // 抛出异常或者内存不足的情况获得改善
        }
        // 申请堆内存成功，调整内存池
        heap_size += bytes_to_get;
        end_free = start_free + bytes_to_get;
        // 递归调用自己，修正 njobs 并返回
        return(chunk_alloc(size, nobjs));
    }
}

template <bool threads, int inst>
void* __default_alloc_template<threads, inst>::refill(size_t n)
{
    int nobjs = 20;
    // 调用 chunk_alloc，尝试取得 njobs 个区块作为 free_list 的新节点
    char * chunk = chunk_alloc(n, nobjs);
    obj * __VOLATILE * my_free_list;
    obj * result;
    obj * current_obj, * next_obj;
    int i;

    // 只获得一个区块
    if (1 == nobjs) return(chunk);
    // 准备调整 free_list，加入新节点
    my_free_list = free_list + FREELIST_INDEX(n);

    // 在 chunk_alloc 中得到的空间构建 free_list 节点
      result = (obj *)chunk;
      *my_free_list = next_obj = (obj *)(chunk + n);
      for (i = 1; ; i++) {
        current_obj = next_obj;
        next_obj = (obj *)((char *)next_obj + n);
        if (nobjs - 1 == i) {
            current_obj -> free_list_link = 0;
            break;
        } else {
            current_obj -> free_list_link = next_obj;
        }
      }
    return(result);
}

template <bool threads, int inst>
void*
__default_alloc_template<threads, inst>::reallocate(void *p,
                                                    size_t old_sz,
                                                    size_t new_sz)
{
    void * result;
    size_t copy_sz;
    // 如果分配区块大小 > 128bytes，直接 realloc
    if (old_sz > (size_t) __MAX_BYTES && new_sz > (size_t) __MAX_BYTES) {
        return(realloc(p, new_sz));
    }
    if (ROUND_UP(old_sz) == ROUND_UP(new_sz)) return(p);
    result = allocate(new_sz);
    copy_sz = new_sz > old_sz? old_sz : new_sz;
    memcpy(result, p, copy_sz);
    deallocate(p, old_sz);
    return(result);
}

上面是部分源码，删掉了多线程的那部分代码。为了方便管理，SGI 第二级配置器会主动将任何小额区块的内存需求量上调至 8 的倍数（例如客户端要求30bytes，就自动调整为 32 bytes），并维护16个 free-lists，各自管理大小分别为：8，16，24，32，40，48，56，64，72，80，88，96，104，112，120，128 bytes的小额区块。

  union obj {
        union obj * free_list_link;
        char client_data[1];    /* The client sees this.        */
  };

对于 联合体 obj，可以理解为：

  • 当 obj 对象未被用户使用时，作为链表指针存在指向下一个obj，这个时候是不需要内存中的数据的
  • 当 obj 对象已被用户使用时，这块内存被分配给用户，client_data用来存数据（client_data 的大小并不是1，而是前面讲的 8 的 16 个整倍数），此时链表指针就没用了

也就是说，每个 obj 在一个时刻只有一个字段有实际意义（free_list_link 或者 client_data），其主要目的是节省内存。

3. 内存基本处理工具

STL 定义有 5 个全局函数，作用于未初始化空间上。前两个是 construct() 和 destroy()，另外 3 个是：

uninitialized_copy()
uninitialized_fill()
uninitialized_fill_n()

它们分别对应于高层次函数 copy()、 fill()、 fill_n()，这些都是 STL 的算法。

uninitialized_copy()、uninitialized_fill()、uninitialized_fill_n() 实际定于于 stl_uninitialized。

// Valid if copy construction is equivalent to assignment, and if the
//  destructor is trivial.
template <class InputIterator, class ForwardIterator>
inline ForwardIterator 
__uninitialized_copy_aux(InputIterator first, InputIterator last,
                         ForwardIterator result,
                         __true_type) {
  return copy(first, last, result);
}

template <class InputIterator, class ForwardIterator>
ForwardIterator 
__uninitialized_copy_aux(InputIterator first, InputIterator last,
                         ForwardIterator result,
                         __false_type) {
  ForwardIterator cur = result;
  __STL_TRY {
    for ( ; first != last; ++first, ++cur)
      construct(&*cur, *first);
    return cur;
  }
  __STL_UNWIND(destroy(result, cur));
}

template <class InputIterator, class ForwardIterator, class T>
inline ForwardIterator
__uninitialized_copy(InputIterator first, InputIterator last,
                     ForwardIterator result, T*) {
  typedef typename __type_traits<T>::is_POD_type is_POD;
  return __uninitialized_copy_aux(first, last, result, is_POD());
}

template <class InputIterator, class ForwardIterator>
inline ForwardIterator
  uninitialized_copy(InputIterator first, InputIterator last,
                     ForwardIterator result) {
  return __uninitialized_copy(first, last, result, value_type(result));
}

inline char* uninitialized_copy(const char* first, const char* last,
                                char* result) {
  memmove(result, first, last - first);
  return result + (last - first);
}

inline wchar_t* uninitialized_copy(const wchar_t* first, const wchar_t* last,
                                   wchar_t* result) {
  memmove(result, first, sizeof(wchar_t) * (last - first));
  return result + (last - first);
}

template <class ForwardIterator, class T>
inline void
__uninitialized_fill_aux(ForwardIterator first, ForwardIterator last, 
                         const T& x, __true_type)
{
  fill(first, last, x);
}

template <class ForwardIterator, class T>
void
__uninitialized_fill_aux(ForwardIterator first, ForwardIterator last, 
                         const T& x, __false_type)
{
  ForwardIterator cur = first;
  __STL_TRY {
    for ( ; cur != last; ++cur)
      construct(&*cur, x);
  }
  __STL_UNWIND(destroy(first, cur));
}

template <class ForwardIterator, class T, class T1>
inline void __uninitialized_fill(ForwardIterator first, ForwardIterator last, 
                                 const T& x, T1*) {
  typedef typename __type_traits<T1>::is_POD_type is_POD;
  __uninitialized_fill_aux(first, last, x, is_POD());

}

template <class ForwardIterator, class T>
inline void uninitialized_fill(ForwardIterator first, ForwardIterator last, 
                               const T& x) {
  __uninitialized_fill(first, last, x, value_type(first));
}

// Valid if copy construction is equivalent to assignment, and if the
//  destructor is trivial.
template <class ForwardIterator, class Size, class T>
inline ForwardIterator
__uninitialized_fill_n_aux(ForwardIterator first, Size n,
                           const T& x, __true_type) {
  return fill_n(first, n, x);
}

template <class ForwardIterator, class Size, class T>
ForwardIterator
__uninitialized_fill_n_aux(ForwardIterator first, Size n,
                           const T& x, __false_type) {
  ForwardIterator cur = first;
  __STL_TRY {
    for ( ; n > 0; --n, ++cur)
      construct(&*cur, x);
    return cur;
  }
  __STL_UNWIND(destroy(first, cur));
}

template <class ForwardIterator, class Size, class T, class T1>
inline ForwardIterator __uninitialized_fill_n(ForwardIterator first, Size n,
                                              const T& x, T1*) {
  typedef typename __type_traits<T1>::is_POD_type is_POD;
  return __uninitialized_fill_n_aux(first, n, x, is_POD());

}

template <class ForwardIterator, class Size, class T>
inline ForwardIterator uninitialized_fill_n(ForwardIterator first, Size n,
                                            const T& x) {
  return __uninitialized_fill_n(first, n, x, value_type(first));
}

// Copies [first1, last1) into [result, result + (last1 - first1)), and
//  copies [first2, last2) into
//  [result, result + (last1 - first1) + (last2 - first2)).

template <class InputIterator1, class InputIterator2, class ForwardIterator>
inline ForwardIterator
__uninitialized_copy_copy(InputIterator1 first1, InputIterator1 last1,
                          InputIterator2 first2, InputIterator2 last2,
                          ForwardIterator result) {
  ForwardIterator mid = uninitialized_copy(first1, last1, result);
  __STL_TRY {
    return uninitialized_copy(first2, last2, mid);
  }
  __STL_UNWIND(destroy(result, mid));
}

// Fills [result, mid) with x, and copies [first, last) into
//  [mid, mid + (last - first)).
template <class ForwardIterator, class T, class InputIterator>
inline ForwardIterator 
__uninitialized_fill_copy(ForwardIterator result, ForwardIterator mid,
                          const T& x,
                          InputIterator first, InputIterator last) {
  uninitialized_fill(result, mid, x);
  __STL_TRY {
    return uninitialized_copy(first, last, mid);
  }
  __STL_UNWIND(destroy(result, mid));
}

// Copies [first1, last1) into [first2, first2 + (last1 - first1)), and
//  fills [first2 + (last1 - first1), last2) with x.
template <class InputIterator, class ForwardIterator, class T>
inline void
__uninitialized_copy_fill(InputIterator first1, InputIterator last1,
                          ForwardIterator first2, ForwardIterator last2,
                          const T& x) {
  ForwardIterator mid2 = uninitialized_copy(first1, last1, first2);
  __STL_TRY {
    uninitialized_fill(mid2, last2, x);
  }
  __STL_UNWIND(destroy(first2, mid2));
}
突然好想晒太阳
关注
专栏目录
【STL源码剖析】总结笔记（5）：认识迭代器的好帮手--list
斯塔克家的真维斯的工作间
10-31 177
00 写在前面 说完vector，也了解了分配器（alloctor），接下来我们说说比较具有代表性的容器list。 【STL源码剖析】总结笔记（3）：vector初识 【STL源码剖析】总结笔记（4）：幕后功臣–分配器（allocator） 为什么说具有代表性呢，因为list的空间不再连续，对空间的使用也更加精准。 学习list也是帮助我们打开迭代器大门的第一步。 01 概述 list和vector是我们平时最常使用的容器。list就是链表，而且根据前置知识我们知道list是一个双向链表。 list的节
【STL源码剖析】总结笔记（1）：开篇
斯塔克家的真维斯的工作间
10-21 634
00 写在前面 STL作为C++标准库中的重要组成部分，在学习C++过程中非常重要。这个可以复用的组件库更像是一个包罗万象的“框架”。 侯捷老师对于STL的了解之深也使我受益匪浅。而《STL源码剖析》这本书也是集精华于一体，深度探索了对于STL的各个部分。配合老师的视频食用极佳。 从这篇开始，我想根据视频和书籍的主要内容做一些整理以及一些理解部分的记录。因为视频部分和书籍部分不完全重合，又是各有精华，所以十分值得去整合在一起理解学习。 学习STL需要读者有一定的C++基础能力，且有一些使用STL的经验，这
stl分析之allocator
qq1010234991的博客
06-25 388
在STL中，Memory Allocator 处于最底层的位置，为一切的 Container 提供存储服务，是一切其他组件的基石。对于一般使用 STL 的用户而言，Allocator 是不可见的，如果需要对 STL 进行扩展，如编写自定义的容器，就需要调用 Allocator 的内存分配函数进行空间配置。 在C++中，一个对象的内存配置和释放一般都包含两个步骤，对于内存的配置，首先是调用op
【STL源码剖析】空间配置器
小小小宁波很靠谱
04-22 234
腾讯二面：聊聊STL的空间配置器。 我：？？？？？然后开始聊vector动态扩容，/(ㄒoㄒ)/~~ SGI STL的配置器与众不同，名称是alloc而非allocator。标准的allocator只是对操作符new和delete的一层薄薄的封装，并没有考虑到任何效率上的优化。 一般而言，我们习惯的C++内存配置操作和释放操作是这样的： class Foo {...}; Foo *pf=...
空间配置器
请给我一支兰州
06-11 99
容器空间配置器的作用：将内存开辟和对象的构造过程分开，内存的释放和对象的析构过程分开。 这么做的理由：如果我们继续使用C++的new和delete，会存在几个问题。第一，我们在构造容器的时候，不仅会开辟容器所需要的内存空间，还会构造出一推无用的对象。第二，我们在删除容器中的元素时，我们希望析构这个元素，但是它的内存空间不能被释放掉，因为我们还要使用容器。所以我们需要容器的空间适配器。 ...
STL源码剖析读书笔记
01-26
STL源码剖析读书笔记 STL（Standard Template Library）的源码剖析读书笔记是对经典著作的总结，涵盖了STL的六大组件、空间分配器、迭代器、仿函式、适配器和容器等知识点。 1. 六大组件 STL提供六大组件，彼此...
《STL源码剖析》学习笔记-第2章 空间配置器
爱橙子的OK绷的专栏
05-04 1346
1、SGI 特殊的空间配置器，std::allocSGI STL 的配置器与众不同，也与标准规范不同，其名称是 alloc 而非 allocator ，而且不接受任何参数。我们所习惯的c++内存配置操作和释放操作如下：class Foo { ... }; Foo* pf = new Foo; // 配置内存，然后构造对象 delete pf; // 将对象析构，然后释放内存这其中的new 操作符（n
STL源码剖析学习笔记之具备次配置力(sub-allocation)的SGI空间配置器
吾尝终日而思矣，不如须臾之所学也
04-12 682
SGI特殊的空间配置器： std::alloc一般而言，我们所习惯的的C++内存配置操作和释放操作是这样的： class Foo {…}; Foo* pf=new Foo;//配置内存，然后构造对象 delete pf; //将对象析构，然后释放内存其中new算式内含两阶段操作： 1.调用 ::operator new 配置内存；template <class T>
STL源码剖析--空间配置器
lvxin15353715790的博客
07-29 173
空间配置器是最不需要介绍的东西，他总是隐藏在容器(container)的背后，默默工作，默默付出。 allocator 之所以说是空间配置器而不是内存配置器，因为空间不一定是内存，也可以是磁盘或者其它辅助存储介质。 空间配置器的标准接口 allocator::allocator() default constructor allocator: :allocator (const allocato...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值