vector第三步修炼之道

最新推荐文章于 2022-02-25 14:35:51 发布

laola的故事

最新推荐文章于 2022-02-25 14:35:51 发布

阅读量374

点赞数

分类专栏： c++ 文章标签： C++-空间配置

本文链接：https://blog.csdn.net/u013266600/article/details/78808065

版权

本文探讨了在C++中优化vector使用的方法，通过分离内存开辟和对象构造，以及析构和内存释放，引入自定义的空间配置器。作者分析了STL库中的allocator，并介绍了如何定义和应用自己的空间配置器来实现vector模板，强调通过阅读和分析源码来提升编程技能。

摘要由CSDN通过智能技术生成

在vector第二步修炼之道中，我们开辟内存都是使用new,释放内存都是delete。在我们使用内置类的时候，看不到区别。如果我们使用自定义类，并且自定义类还比较复杂，那么这种优化就显得很重要了。
new操作符主要干两件事：
（1）申请内存；
（2）初始化
delete 操作符主要干两件事：
（1）释放内存；
（2）析构
那么在上一个篇博客中，我们就看到优化的地方。我们需要将申请内存和初始化分开进行；将析构和释放内存分开进行。
问题：
因此，如何把一个对象的内存开辟和对象构造分开，对象析构和内存释放分开？
解决方案：
内存开辟：operator new(size)
char p = (char)operator new(size);
在一个已经开辟好的内存上构造对象：定位new
A *pa = new (p) A();

对象的析构和内存释放分开
析构：pa->~A();
释放内存：operator delete(pa);

在STL 库中，有自定义的配置器：allocator。我看了下STL库中的源码：

#ifdef __STL_USE_STD_ALLOCATORS

template <class _Tp>
class allocator {
  typedef alloc _Alloc;          // The underlying allocator.
public:
  typedef size_t     size_type;
  typedef ptrdiff_t  difference_type;
  typedef _Tp*       pointer;
  typedef const _Tp* const_pointer;
  typedef _Tp&       reference;
  typedef const _Tp& const_reference;
  typedef _Tp        value_type;

  template <class _Tp1> struct rebind {
    typedef allocator<_Tp1> other;
  };

  allocator() __STL_NOTHROW {}
  allocator(const allocator&) __STL_NOTHROW {}
  template <class _Tp1> allocator(const allocator<_Tp1>&) __STL_NOTHROW {}
  ~allocator() __STL_NOTHROW {}

  pointer address(reference __x) const { return &__x; }
  const_pointer address(const_reference __x) const { return &__x; }

  // __n is permitted to be 0.  The C++ standard says nothing about what
  // the return value is when __n == 0.
  _Tp* allocate(size_type __n, const void* = 0) {
    return __n != 0 ? static_cast<_Tp*>(_Alloc::allocate(__n * sizeof(_Tp))) 
                    : 0;  //申请空间
  }

  // __p is not permitted to be a null pointer.
  void deallocate(pointer __p, size_type __n)
    { _Alloc::deallocate(__p, __n * sizeof(_Tp)); } //回收空间

  size_type max_size() const __STL_NOTHROW 
    { return size_t(-1) / sizeof(_Tp); }

  void construct(pointer __p, const _Tp& __val) { new(__p) _Tp(__val); }  //使用定位new构造
  void destroy(pointer __p) { __p->~_Tp(); }  //析构函数
};

  static void* allocate(size_t __n)
  {
    void* __result = malloc(__n);   //底层开辟空间使用malloc
    if (0 == __result) __result = _S_oom_malloc(__n);
    return __result;
  }

  static void deallocate(void* __p, size_t /* __n */)
  {
    free(__p);