Vector implementation using allocator class
    
    #ifndef __VECTOR_H__
    #define __VECTOR_H__
    
    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
    
This is an implementation of the vector class. How it would be like if I used the allocator class as a second template parameter. Which version is faster and more efficient? 
<code>`template<class T, class Allocator = allocator<T> >`</code>
This is how it looks like on the file stl_vector.h
Vector implementation using allocator class
===

    
    #ifndef __VECTOR_H__
    #define __VECTOR_H__
    
    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
    
This is an implementation of the vector class. How it would be like if I used the allocator class as a second template parameter. Which version is faster and more efficient? 
<code>`template<class T, class Allocator = allocator<T> >`</code>
This is how it looks like on the file stl_vector.h