STL深入剖析——————第二章：空间配置器

本文链接：https://blog.csdn.net/wso4133560/article/details/25605557

本章主要是空间配置器，一般我们都不用管的。不过弄懂这个对接下来的很多内容都可以搞懂，这个还可以提高STL的效率。

下面是allocator的必要接口：

allocator::value_type

allocator::pointer

allocator::const_pointer

allocator::reference

allocator::const_reference

allocator::size_type

allocator::difference_type

allocator::rebind

allocator::allocator()

allocator::allocator(const allocator&)

template<class U>allocator::allocator(const allocator<U>&)

allocator::~allocator()

pointer allocator::address(reference x)const

const_pointer allocator::address(const_reference x)const

pointer allocator::allocate(size_tyoe n, const void* = 0)

void allocator::deallocate(pointer p, size_type n)

size_type allocator::max_size() const

void allocator::construct(pointer p, const T& x)

void allocator::destroy(pointer p)

根据上面的接口设计一个简单的控件配置器

生成两个文件jjalloc.h和main.cpp

jjalloc.h

#pragma once

#include <new>
#include <cstddef>
#include <cstdlib>
#include <climits>
#include <iostream>

namespace JJ
{
template <class T>
inline T* _allocate(ptrdiff_t size, T*)
{
set_new_handler(0);
T* tmp = (T*)(::operator new ((size_t)(size * sizeof(T))));

if (tmp == 0)
{
cerr << "out of memory" << endl;
exit(1);
}

return tmp;
}

template <class T>
inline void _deallocate(T* buffer)
{
::operator delete(buffer);
}

template <class T1, class T2>
inline void _construct(T1* p, const T2& value)
{
new(p) T1(value);
}

template <class T>
inline void _destroy(T* ptr)
{
ptr->~T();
}

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 size_t size_type;
typedef ptrdiff_t difference_type;

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

allocator()
{
return;
}

template <class U>
allocator(const allocator<U>& c)
{

}

pointer allocate(size_type n, const void* hint = 0)
{
return _allocate((difference_type)n, (pointer)0);
}

void deallocate(pointer p, size_type n)
{
_deallocate(p);
}

void construct(pointer p, const T& value)
{
_construct(p, value);
}

void destroy(pointer p)
{
_destroy(p);
}

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));
}
};

}

/

main.cpp的

#include "jjalloc.h"
#include <vector>
#include <iostream>

using namespace std;

int main()
{
int ia[5] = {0, 1, 2 ,3 ,4};
unsigned int i;

vector<int, JJ::allocator<int>> iv(ia, ia + 5);

for (i = 0; i < iv.size(); i++)
{
cout << iv[i] << endl;
}
}