使用分配器類的矢量實現

#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

這是vector類的實現。它使用T類型的動態數組，它隨着reserve（）函數的增長而變大。如何使用分配器類來實現它？（全矢量類，而不僅僅是儲備功能）使用分配器類的矢量實現

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

這是怎麼看起來像文件stl_vector.h

來源

2012-04-18 Rontogiannis Aristofanis

你問的是哪個版本更快/更高效，而沒有說明你的替代品是什麼。你已經給出了一個選項（'template ''）。我會假定從你提供的備選方案中選擇最快的一個... – Grizzly 2012-04-18 15:09:00

包含雙下劃線的標識符（包括宏名稱），或者以下劃線開頭，後面跟着大寫字母，這些標識符是爲實現保留的。切勿在自己的代碼中使用它們。 – 2012-04-18 15:15:22

謝謝，我會記住它的。 – 2012-04-18 15:18:31

的STL的默認分配有效地調用new運算符來完成它的工作。所以我認爲這不會有太大的改變。但是，通過查看代碼無法充分回答性能問題。相反，您應該使用一些典型的測試數據來實現這兩個版本和測量。

來源

2012-04-18 18:08:32 bjhend

使用分配器類的矢量實現

回答

相關問題