0 
#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

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

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

これは、ファイルstl_vector.hでどのように表示されるかを示しています。

4

1 に答える 1

0

STL のデフォルト アロケータは、効果的に new 演算子を呼び出してその作業を行います。なので、あまり変わらないと思います。しかし、パフォーマンスの問題は、コードを見ただけでは十分に答えることはできません。代わりに、両方のバージョンを実装し、いくつかの典型的なテスト データで測定する必要があります。

于 2012-04-18T18:08:32.127 に答える