STL学习笔记：空间配置器allocator

allocator必要接口：

allocator::value_type

allocator::pointer

allocator::const_pointer

allocator::reference

allocator::const_reference

allocator::size_type

allocator::difference_type

allocator::rebind

 自定义allocator，书上说此空间配置其完全无法应用于SGI STL allocator，但是现在应该修改了，默认的空间配置器也是std::allocator

//2jjalloca.h

#ifndef _2JJALLOCA_H_
#define _2JJALLOCA_H_

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

using namespace std;

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))));
    //operator new可以被重载
    if (tmp == 0) {
        cerr << "out of memory" << endl;
        exit(1);
    }
    return tmp;
}

template<class T>
inline void _deallocate(T* buffer) {
    ::operator delete(buffer);
    //operator delete可以被重载
//    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;

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

    //hint used for locality. ref.[Austern],p189
    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));
    }

};

}//end of namespace JJ

#endif /* _2JJALLOCA_H_ */

//main.cpp

#include <iostream>
#include <vector>
#include "2jjalloca.h"

using namespace std;

int main(int argc, char **argv) {
    int ia[5] = { 0, 1, 2, 3, 4 };
    unsigned int i;
    fprintf(stderr, "ia addr:%p
", ia);
    vector<int, JJ::allocator<int>> iv(ia, ia + 5);
    for (i = 0; i < iv.size(); i++) {
        cout << iv[i] << ' ';
    }
    cout << endl;
    return 0;
}

运行结果也是正常的

================>现在由此引申出一个问题，operator new

#include <iostream>
#include <new>
#include <limits.h>
#include <stddef.h>

using namespace std;

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

    pointer allocate(size_type n) {
        return ::allocate((difference_type) n, (T*) 0);
    }

    void deallocate(pointer p) {
        ::deallocate(p);
    }

    pointer address(reference x) {
        return (pointer) &x;
    }

    const_pointer const_address(const_reference x) {
        return (const_pointer) &x;
    }

    size_type init_page_size() {
        return max(size_type(1), size_type(4096 / sizeof(T)));
    }

    size_type max_size() const {
        return max(size_type(1), size_type(UINT_MAX / sizeof(T)));
    }
};

template<>
class Allocator<void> {
public:
    typedef void* pointer;
};

int main(int argc, char **argv) {

    return 0;
}

STL源码po析所说，SGI定义了一个有部分符合标准的allocator配置器(上面的代码)，但是我看了自己本地的代码，似乎很符合标准呀。