实现自己的STL配置器allocator

小咪咪 2021-12-05 12:57 271阅读 0赞

#### 实现自己的STL配置器 ####

STL所有数据都存储在容器之中，而容器需要配置空间以置放资料，所以配置器就是完成这一个任务的。

以下是它的一些接口

allocator::value_type
    //类型，如int
    
    allocator::pointer
    //指针，如int *
    
    allocator::const_pointer
    
    allocator::reference
    //引用， 如int &
    
    allocator::const_reference
    
    
    allocator::size_type
    //大小，如size_t
    
    allocator::difference_type
    //difference_type是一种常用的迭代器型别，用来表示两个迭代器之间的距离，因此它也可以用来表示一个容器的最大容量，因为对于连续空间的容器而言，头尾之间的距离就是其最大容量。
    
    allocator::rebind
    //rebind实现了对不同类型使用同一种内存分配策略的要求
    
    allocator::allocator()
    //默认的构造函数
    
    allocator::allocator(const allocator&)
    //复制构造函数
        
    template <class U>allocator::allocator(const allocator<U>&)
    //泛化复制构造函数
        
    allocator::~allocator()
    //析构函数
    pointer allocator::address(reference x) const
    //返回某个对象的地址，a.address(x) 相当于 &x
        
    const_pointer allocator::address(const_reference x) const
    //返回某个对象的地址，a.address(x) 相当于 &x
    
    pointer allocator::allocate(size_type n, const void* = 0)
    //分配可以存储n个T对象的空间。第二个参数是个提示，实现上可能会用它来增进区域性（locality），或完全忽略之
        
    void allocator::deallocator(pointer p, size_type n)
    //清除空间
        
    size_type allocator::max_size() const
    //返回可以配置的最大值
        
    void allocator::construct(pointer p, const T& x)
    //等同于new (const void*) p T(x)
        
    void allocator::destroy(pointer p)
    //等同于p->~T()

##### 一个简陋的实现 #####

#ifndef _MYALLOCATOR
    #define _MYALLOCATOR
    
    #include <new>
    #include <cstdlib>
    #include <cstddef>
    #include <climits>
    #include <iostream>
    
    namespace My
    {
        
    	//************************************
    	// Method:    _allocate
    	// Desc:	  分配空间的函数，实际上是调用了operator new，稍后将会讲述operator new
    	// Author:    
    	// Date: 	  2019/07/17
    	// FullName:  My::_allocate
    	// Access:    public 
    	// Returns:   T*
    	// Qualifier:
    	// Parameter: ptrdiff_t size：	分配空间的大小
    	// Parameter: T *：				类型
    	//************************************
    	template <class T>
    	inline T* _allocate(ptrdiff_t size, T*)
    	{
        
    		set_new_handler(0);
            
            //operator new只是用来申请内存空间，并没有调用构造函数
    		T* TMP = (T *)(::operator new((size_t)(size * sizeof(T))));
            
    		if (TMP == 0)
    		{
        
    			cerr << "out of memory" << endl;
    			exit(1);
    		}
    		return TMP;
    	}
    
    	//************************************
    	// Method:    _deallocator
    	// Desc:	  回收空间的函数
    	// Author:    
    	// Date: 	  2019/07/17
    	// FullName:  My::_deallocator
    	// Access:    public 
    	// Returns:   void
    	// Qualifier:
    	// Parameter: T * buffer：	buffer指向已经想回收的地址
    	//************************************
    	template <class T>
    	inline void _deallocator(T* buffer)
    	{
        
    		::operator delete(buffer);
    	}
    
    	//************************************
    	// Method:    _construct
    	// Desc:	  调用类的构造函数，稍后讲述new
    	// Author:    
    	// Date: 	  2019/07/17
    	// FullName:  My::_construct
    	// Access:    public 
    	// Returns:   void
    	// Qualifier:
    	// Parameter: T1 * p：			指向实际存储空间的指针
    	// Parameter: const T2 & value：	该类型的值
    	//************************************
    	template <class T1, class T2>
    	inline void _construct(T1 *p, const T2& value)
    	{
        
            //placement new用于调用构造函数
    		new (p)T1(value);
    	}
    
    	//************************************
    	// Method:    _destroy
    	// Desc:	  调用析构函数
    	// Author:    
    	// Date: 	  2019/07/17
    	// FullName:  My::_destroy
    	// Access:    public 
    	// Returns:   void
    	// Qualifier:
    	// Parameter: T * ptr：		指向地址的指针
    	//************************************
    	template <class T>
    	inline void _destroy(T* ptr)
    	{
        
    		ptr->~T();
    	}
    
    
    	//allocator类实际上是上面几个函数的封装，相似的函数不再详细讲述
    	template <class T>
    	class allocator
    	{
        
    	public:
    		typedef T			value_type;
    		typedef T*			pointer;
    		typedef const T*	const_pointer;
    		typedef T&			reference;
    		typedef const T&	const_reference;
    		typedef ptrdiff_t	difference_type;
    		typedef size_t		size_type;
    
    		template <class U>
    		struct rebind
    		{
        
    			typedef	allocator<U> other;
    		};
    
    		pointer allocate(size_type n, const void* hint = 0)
    		{
        
    			return _allocate((difference_type)n, (pointer)0);
    		}
    
    		void deallocate(pointer p, size_t n)
    		{
        
    			_deallocator(p);
    		}
    
    		void construct(pointer p, const T& value)
    		{
        
    			_construct(p, value);
    		}
    
    		void destroy(pointer p)
    		{
        
    			_destroy(p);
    		}
    
    
    		//************************************
    		// Method:    address
    		// Desc:	  返回地址
    		// Author:    
    		// Date: 	  2019/07/17
    		// FullName:  My::allocator<T>::address
    		// Access:    public 
    		// Returns:   pointer
    		// Qualifier:
    		// Parameter: reference x
    		//************************************
    		pointer address(reference x)
    		{
        
    			return (pointer)&x;
    		}
    
    		const_pointer const_address(const_reference x)
    		{
        
    			return (const_pointer)&x;
    		}
    
    		size_type max_size() const
    		{
        
    			return size_type(UINT_MAX / sizeof(T));
    		}
    
    	};
    }
    
    #endif

##### 测试 #####

#include <vector>
    #include "MyAllocator.h"
    
    using namespace std;
    
    int main()
    {
    	vector<int, My::allocator<int>> vec(10, 1);
    	for (int i = 0; i < 10; i++)
    	{
    		cout << vec[i] << " ";
    	}
    	getchar();
    
    }

可以看出没有错误，但是这里实现的allocator只是十分简陋的，并没有做一些内存的优化。

##### new讲解 #####

new有三种使用方式：plain new，nothrow new和placement new。

（1）plain new顾名思义就是普通的new，就是我们惯常使用的new。在C++中是这样定义的：  
`void* operator new(std::size_t) throw(std::bad_alloc);`  
`void operator delete(void *) throw();`

提示：plain new在分配失败的情况下，抛出异常std::bad\_alloc而不是返回NULL，因此通过判断返回值是否为NULL是徒劳的。

（2）nothrow new是不抛出异常的运算符new的形式。nothrow new在失败时，返回NULL。定义如下：  
`void * operator new(std::size_t,const std::nothrow_t&) throw();`  
`void operator delete(void*) throw();`

（3）placement new意即“放置”，这种new允许在一块已经分配成功的内存上重新构造对象或对象数组。placement new不用担心内存分配失败，因为它根本不分配内存，它做的唯一一件事情就是调用对象的构造函数。定义如下：  
`void* operator new(size_t,void*); void operator delete(void*,void*);`

提示1：palcement new的主要用途就是反复使用一块较大的动态分配的内存来构造不同类型的对象或者他们的数组。

提示2：placement new构造起来的对象或其数组，要显示的调用他们的析构函数来销毁，千万不要使用delete。

`char* p = new(nothrow) char[100]; //plain new`

`long *q1 = new(p) long(100); //nothrow new`

`int *q2 = new(p) int[100/sizeof(int)]; //placement new`

下面是一个例子

class TestClass
    {
        
    public:
    	int a;
    	TestClass()
    	{
        
    		std::cout << "constructor" << std::endl;
    	}
    };
    
    void Test()
    {
        
    	char *ts = (char*)malloc(sizeof(TestClass));
        //char *ts = operator new(sizeof(TestClass));
    	std::cout << "emm" << std::endl;
    	reinterpret_cast<TestClass*>(ts);
    	new(ts) TestClass();
        
        /*
        TestClass *ts = operator new(sizeof(TestClass));
        std::cout<<"emm"<<std::endl;
        new(ts) TestClass();
        */
    	
    }

输出

emm
    constructor

参考《STL源码剖析》