C++ 使用分配器类的向量实现 #ifndef向量 #定义向量 模板 结构向量 { 私人： T*缓冲器； 未签名的long sz； 无符号长帽； 公众： 类型定义T值_类型； 类型定义值\u类型和参考； 类型定义常数参考常数参考； typedef值\u type*指针； 类型定义常量指针常量指针； typedef T*迭代器； typedef常量T*常量迭代器； typedef无符号长尺寸_类型； typedef ptrdiff_t difference_type； vector（）：buffer（newint[10]），sz（0），cap（10）{ 向量（size_t s）：缓冲区（newint[sz]），sz（s），cap（s）{} 向量（size_t s，const t&initial）：缓冲区（new int[sz]），sz（s），cap（s）{for（size_t i=0；i=sz）抛出std：：超出范围（“超出范围”）；返回缓冲区[index]；} const T&运算符[]（size_T index）const{if（index>=sz）throw std:：out_of_range（“out_of_rane”）；返回缓冲区[index]；} T&at（size_T index）{return（*this）[index]；} const T&at（size_T index）const{return（*this）[index]；} }; #恩迪夫

这是vector类的一个实现。它使用类型为T的动态数组，该数组随着reserve（）函数的增加而变大。如果我使用分配器类来实现它，会是什么样子？（整个向量类，而不仅仅是保留函数）

模板

---

这就是它在文件stl_vector.h上的样子，stl的默认分配器有效地调用新操作符来完成它的工作。所以我想这不会有太大变化。但是，通过查看代码永远无法充分回答性能问题。相反，您应该实现这两个版本，并使用一些典型的测试数据进行测量。

您询问的是哪个版本更快/更高效，而没有说明您的备选方案。您给出了一个选项（

模板

）。我假设其中一个是您给出的备选方案中速度最快的……包含双下划线或以下划线开头，后跟大写字母的标识符（包括宏名称）将保留给实现。不要在自己的代码中使用它们。谢谢，我会记住它。你的构造函数声明不是根据C++标准，它不使用<代码>不管怎样，您与分配器的备选方案是什么样的？您可能希望重新表述/重新询问您的问题，使其与备选分配器的实现有关，而不是性能方面，顺便说一句，这不是模板参数的原因。

#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

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