MyTinySTL学习-分配器

一. 学习中遇到的问题

1. forward和move

1.1. move

假如有一个class A, 带有一个set函数, 可以传两个参数赋值class里的成员变量:

class A{...};

void A::set(const string & var1, const string & var2){
  m_var1 = var1;    //copy
  m_var2 = var2;    //copy
}

下面这个写法是没法避免copy的, 因为怎么着都得把外部初始的string传进set函数, 再复制给成员变量:

A a1;
string var1("string1");
string var2("string2");
a1.set(var1, var2);   // OK to copy

但下面这个呢? 临时生成了2个string, 传进set函数里, 复制给成员变量, 然后这两个临时string再被回收.

A a1;
a1.set("temporary str1","temporary str2");   //temporary, unnecessary copy

上面复制的行为, 在底层的操作很可能是这样的:

(1)临时变量的内容先被复制一遍

(2)被复制的内容覆盖到成员变量指向的内存

(3)临时变量用完了再被回收

这里能不能优化一下呢? 临时变量反正都要被回收, 如果能直接把临时变量的内容, 和成员变量内容交换一下, 就能避免复制了? 如下:

(1)成员变量内部的指针指向"temporary str1"所在的内存

(2)临时变量内部的指针指向成员变量以前所指向的内存

(3)最后临时变量指向的那块内存再被回收

上面这个操作避免了一次copy的发生, 其实它就是所谓的move语义.

为了解决这个问题，于是引入了左值和右值的概念，之前说的临时变量就是右值，，上面所说避免copy的操作就是std::move。

再回到我们的例子:

没法避免copy操作的时候, 还是要用const T &把变量传进set函数里, 现在T &叫lvalue reference(左值引用)了, 如下:

void set(const string & var1, const string & var2){
  m_var1 = var1;  //copy
  m_var2 = var2;  //copy
}
A a1;
string var1("string1");
string var2("string2");
a1.set(var1, var2);   // OK to copy

传临时变量的时候, 可以传T &&, 叫rvalue reference(右值引用), 它能接收rvalue(临时变量), 之后再调用std::move就避免copy了.

void set(string && var1, string && var2){
  //avoid unnecessary copy!
  m_var1 = std::move(var1);  
  m_var2 = std::move(var2);
}
A a1;
//temporary, move! no copy!
a1.set("temporary str1","temporary str2");

新的问题: 避免重复

1.2. forward

上面说的各种情况, 包括传const T &, T &&, 都可以由以下操作代替:

template<typename T1, typename T2>
void set(T1 && var1, T2 && var2){
  m_var1 = std::forward<T1>(var1);
  m_var2 = std::forward<T2>(var2);
}

//当var1是一个右值, std::forward<T1> 等价于 static_cast<[const] T1 &&>(var1)
//当var1是一个左值, std::forward<T1> 等价于 static_cast<[const] T1 &>(var1)

forward能转发以下情况：

const T &
T &
const T &&
T &&

如果外面传来了rvalue临时变量, 它就转发rvalue并且启用move语义.

如果外面传来了lvalue, 它就转发lvalue并且启用复制. 然后它也还能保留const.

2. new

2.1 ::new 和 new

在全局命名空间中有一个自带的、隐藏的operator new专门用来分配内存。默认情况下编译器会将new这个关键字翻译成这个operator new和相应的构造函数。

但在有的情况下，用户自己会在类中重载operator new，这种情况下，编译器默认会使用类中重载的operator new（本质上因为编译器会从命名空间由内而外查找自己想要的函数，选用第一个）。

如果我们想要继续使用默认的operator new，就应该写成::new 字面意思就是调用最外层命名空间中的operator new

2.2 placement new

new，先分配内存，后调构造函数。那么，可不可以保持一块内存，反复构造析构，这样可以省略中间的多次分配内存。由于malloc内存会导致系统调用（malloc()之后，内核发生了什么），这可以节省大量的系统开销。C++标准也是这么想的，所以他们提供了placement new。

    char* ptr = new char[sizeof(T)]; // allocate memory  
    T* tptr = new(ptr) T;            // construct in allocated storage ("place")  
    tptr->~T();                      // destruct  
    delete[] ptr;                    // deallocate memory  

二. MyTinySTL分配器

涉及construct.h、allocator.h文件

首先对于C++中的delete和new函数进行一些解释：
	在我们使用new来建造一个对象的时候，一般是分为两个步骤的：
	1.调用::operator new()来构建空间；
	2.调用对象的构造函数。
	注：::operator new内部由malloc实现、省略指针转换这步。

	同理，当我们使用delete函数的时候：
	1.调用对象的析构函数
	2.调用::operator delete()释放空间。
	注：::operator delete内部由free实现

在STL的实现中，为了精细分工、STL allocator决定将上述步骤的两阶段操作分开来，内存
配置操作由alloc::allocate()负责，内存释放由alloc::deallocate负责，对象构建
操作由construct负责，对象析构操作由destroy负责。接下来我们梳理内存配置器的具体
实现流程。

construct

使用placement new来进行构造；这是operator new的一个重载版本、允许你在一个已经分配好的内存中（栈或堆中）构造一个新的对象，其中的void*p实际上就是指向一个已经分配好的内存缓冲区的的首地址。

template <class Ty>
    void construct(Ty *ptr)
    {
        ::new ((void*)ptr) Ty();
    }

    template <class Ty1, class Ty2>
    void construct(Ty1* ptr, const Ty2& value)
    {
        ::new ((void*)ptr) Ty1(value);
    }

    template <class Ty, class... Args>
    void construct(Ty* ptr, Args&&... args)
    {
        ::new ((void*)ptr) Ty(mystl::forward<Args>(args)...);
    }

destory

我们传入的是一个指针的时候，会调用destroy_one()函数，当我们发现传入的析构函数是重要的时候、我们调用destroy_one()函数的false_type特化版本，直接调用析构函数即可；
当传入两个迭代器的时候，如果发现是重要的析构函数，那么我们对于每个迭代器调用destroy()函数，此时传入的是当前迭代器，相应的调用的就会是之前所说的destroy_one的特化的版本对对象进行析构。

template <class Ty>
    void destroy_one(Ty*, std::true_type) {}

    template <class Ty>
    void destroy_one(Ty* pointer, std::false_type)
    {
        if (pointer != nullptr)
        {
            pointer->~Ty();
        }
    }

    template <class ForwardIter>
    void destroy_cat(ForwardIter, ForwardIter, std::true_type) {}

    template <class ForwardIter>
    void destroy_cat(ForwardIter first, ForwardIter last, std::false_type)
    {
        for(; first != last; ++first)
            destroy(&*first);
    }

    /*
    std::is_trivially_denstructible模板用于检查T是否是普通可破坏类型。
    如果T是普通可破坏类型，则返回布尔值true；否则返回false。
    */
    template <class Ty>
    void destroy(Ty* pointer)
    {
        destory_one(pointer, std::is_trivially_destructible<Ty> {});
    }

    template <class ForwardIter>
    void destroy(ForwardIter first, ForwardIter last)
    {
        destroy_cat(first, last, std::is_trivially_destructible<
              typename iterator_traits<ForwardIter>::value_type>{});
    }

allocator

类
template <class T>
    class allocator
    {
    public:
        typedef T            value_type;		/*! 数据类型 */
        typedef T*           pointer;			/*! 数据类型指针 */
        typedef const T*     const_pointer;		/*! const数据类型指针 */
        typedef T&           reference;			/*! 数据类型引用 */
        typedef const T&     const_reference;	/*! const数据类型引用 */
        typedef size_t       size_type;			/*! 数据类型大小 */
        typedef ptrdiff_t    difference_type;	/*! 数据类型指针距离 */ 
    
    public:
        // 分配内存
        static T*   allocate();
        static T*   allocate(size_type n);

        // 回收内存
        static void deallocate(T* ptr);
        static void deallocate(T* ptr, size_type n);

        // 构造对象
        static void construct(T* ptr);
        static void construct(T* ptr, const T& value);
        static void construct(T* ptr, T&& value);

        template <class... Args>
        static void construct(T* ptr, Args&& ...args);

        // 析构对象
        static void destroy(T* ptr);
        static void destroy(T* first, T* last);
    };

allocator实现

template <class T>
    T* allocator<T>::allocate()
    {
        return static_cast<T*>(::operator new(sizeof(T)));
    }

    template <class T>
    T* allocator<T>::allocate(size_type n)
    {
        if (n == 0)
            return nullptr;
        return static_cast<T*>(::operator new(n * sizeof(T)));
    }

deallocate

template <class T>
    void allocator<T>::deallocate(T* ptr)
    {
        if (ptr == nullptr)
            return;
        ::operator delete(ptr);
    }

    template <class T>
    void allocator<T>::deallocate(T* ptr, size_type /*size*/)
    {
        if (ptr == nullptr)
            return;
        ::operator delete(ptr);
    }

construct

template <class T>
    void allocator<T>::construct(T* ptr)
    {
        mystl::construct(ptr);
    }

    template <class T>
    void allocator<T>::construct(T* ptr, const T& value)
    {
        mystl::construct(ptr, value);
    }

    template <class T>
    void allocator<T>::construct(T* ptr, T&& value)
    {
        mystl::construct(ptr, mystl::move(value));
    }

    template <class T>
    template<class ...Args>
    void allocator<T>::construct(T* ptr, Args&&... args)
    {
        mystl::construct(ptr, mystl::forward<Args>(args)...);
    }

destory

template <class T>
    void allocator<T>::destroy(T* ptr)
    {
        mystl::destroy(ptr);
    }

    template <class T>
    void allocator<T>::destroy(T* first, T* last)
    {
        mystl::destroy(first, last);
    }

参考：
深入解析new、operator new、::new、placement new
move和forward
STL源码剖析：1.空间配置器
MyTinySTL阅读笔记—分配器