アロケータクラスを使用したベクターの実装

Question

#ifndef VECTOR 
#define VECTOR 

template<typename T> 
struct vector 
{ 
private: 
    T *buffer; 
    unsigned long sz; 
    unsigned long cap; 
public: 
    typedef T value_type; 
    typedef value_type& reference; 
    typedef const reference const_reference; 
    typedef value_type* pointer; 
    typedef const pointer const_pointer; 
    typedef T* iterator; 
    typedef const T* const_iterator; 
    typedef unsigned long size_type; 
    typedef ptrdiff_t difference_type; 

    vector() : buffer(new int[10]), sz(0), cap(10) {} 
    vector(size_t s) : buffer(new int[sz]), sz(s), cap(s){} 
    vector(size_t s, const T& initial) : buffer(new int[sz]), sz(s), cap(s) { for(size_t i = 0; i < sz; i++) buffer[i] = initial; } 
    template<typename container, typename It> 
    vector(typename container::It beg, typename container::It end) 
    { 
     It iter(beg); 
     sz = ptrdiff_t(beg-end); 
     cap = sz; 

     for(int i = 0; i < sz; i++) 
     { 
      buffer[i] = iter++; 
     } 
    } 
    ~vector() {delete [] buffer;} 

    iterator begin() {return buffer;} 
    const_iterator begin() const {return buffer;} 

    iterator end() {return buffer+sz;} 
    const_iterator end() const {return buffer+sz;} 

    void reserve(size_t newCap) 
    { 
     if(newCap <= cap) return; 
     T *oldBuffer = buffer; 

     buffer = new T[newCap]; 

     for(int i = 0; i < cap; i++) 
     { 
      buffer[i] = oldBuffer[i]; 
     } 

     cap = newCap; 
     delete [] oldBuffer; 
    } 
    void resize(size_t newSz, const T& initial = T()) 
    { 
     if(newSz > cap) 
      reserve((newSz*2+1)%(max_size()+1)); 
     if(newSz > sz) 
     { 
      for(int i = sz; i < newSz; i++) 
       buffer[i] = initial; 
     } 
     sz = newSz; 
    } 
    size_t size() const {return sz;} 
    size_t capacity() const {return cap;} 
    bool empty() const {return sz == 0;} 
    size_t max_size() const {return 1073741823;} 
    void push_back(T toP) 
    { 
     if(sz >= cap) 
      reserve((cap*2+1)%(max_size()+1)); 
     buffer[sz++] = toP; 
    } 
    T pop_back() 
    { 
     T ret = buffer[sz-1]; 
     buffer[sz-1] = T(); 
     sz--; 
     return ret; 
    } 
    reference front() { return buffer[0]; } 
    const_reference front() const { return buffer[0]; } 

    reference back() { return buffer[sz-1]; } 
    const_reference back() const { return buffer[sz-1]; } 

    T& operator[](size_t index) {if(index >= sz) throw std::out_of_range("out_of_rane"); return buffer[index]; } 
    const T& operator[] (size_t index) const {if(index >= sz) throw std::out_of_range("out_of_rane"); return buffer[index];} 

    T& at(size_t index) { return (*this)[index]; } 
    const T& at(size_t index) const { return (*this)[index]; } 
}; 

#endif 

これはベクタークラスの実装です。これは、型Tの動的配列を使用します。これは、関数reserve（）によって大きくなります。それを実装するためにアロケータクラスを使用した場合、どうなるでしょうか？ （全体のベクトルクラスだけでなく、予備の機能）

template<class T, class Allocator = allocator<T> > 

これはSTLのデフォルトのアロケータが効果的に仕事をするためにnew演算子を呼び出して、ファイルstl_vector.h

Answer 1

のように、それがどのように見えるかです。だから私はそれがあまり変わらないと思います。しかし、パフォーマンスの問題は、コードを見ることで決して十分に答えることはできません。代わりに、両方のバージョンを実装し、いくつかの典型的なテストデータで測定する必要があります。