vector

#ifndef __TYPETRAIT__H__#define __TYPETRAIT__H__#include <cstddef>namespace stc{class trueType{};class falseType{};template <typename type>class typeTrait{public:typedef trueTypethisDummyMemberMustBeFirst;typedef falseTypehasTrivalDefaultCtor;typedef falseTypehasTrivalCopyCtor;typedef falseTypehasTrivalAssignmentOperator;typedef falseTypehasTrivalDtor;typedef falseTypeisPODType;};template <> class typeTrait < signed char > {public:typedef trueTypehasTrivalDefaultCtor;typedef trueTypehasTrivalCopyCtor;typedef trueTypehasTrivalAssignmentOperator;typedef trueTypehasTrivalDtor;typedef trueTypeisPODType;};template <> class typeTrait < unsigned char > {public:typedef trueTypehasTrivalDefaultCtor;typedef trueTypehasTrivalCopyCtor;typedef trueTypehasTrivalAssignmentOperator;typedef trueTypehasTrivalDtor;typedef trueTypeisPODType;};template <> class typeTrait < wchar_t > {public:typedef trueTypehasTrivalDefaultCtor;typedef trueTypehasTrivalCopyCtor;typedef trueTypehasTrivalAssignmentOperator;typedef trueTypehasTrivalDtor;typedef trueTypeisPODType;};template <> class typeTrait < short > {public:typedef trueTypehasTrivalDefaultCtor;typedef trueTypehasTrivalCopyCtor;typedef trueTypehasTrivalAssignmentOperator;typedef trueTypehasTrivalDtor;typedef trueTypeisPODType;};template <> class typeTrait < unsigned short > {public:typedef trueTypehasTrivalDefaultCtor;typedef trueTypehasTrivalCopyCtor;typedef trueTypehasTrivalAssignmentOperator;typedef trueTypehasTrivalDtor;typedef trueTypeisPODType;};template <> class typeTrait < int > {public:typedef trueTypehasTrivalDefaultCtor;typedef trueTypehasTrivalCopyCtor;typedef trueTypehasTrivalAssignmentOperator;typedef trueTypehasTrivalDtor;typedef trueTypeisPODType;};template <> class typeTrait < unsigned int > {public:typedef trueTypehasTrivalDefaultCtor;typedef trueTypehasTrivalCopyCtor;typedef trueTypehasTrivalAssignmentOperator;typedef trueTypehasTrivalDtor;typedef trueTypeisPODType;};template <> class typeTrait < long > {public:typedef trueTypehasTrivalDefaultCtor;typedef trueTypehasTrivalCopyCtor;typedef trueTypehasTrivalAssignmentOperator;typedef trueTypehasTrivalDtor;typedef trueTypeisPODType;};template <> class typeTrait < long long> {public:typedef trueTypehasTrivalDefaultCtor;typedef trueTypehasTrivalCopyCtor;typedef trueTypehasTrivalAssignmentOperator;typedef trueTypehasTrivalDtor;typedef trueTypeisPODType;};template <> class typeTrait < unsigned long > {public:typedef trueTypehasTrivalDefaultCtor;typedef trueTypehasTrivalCopyCtor;typedef trueTypehasTrivalAssignmentOperator;typedef trueTypehasTrivalDtor;typedef trueTypeisPODType;};template <> class typeTrait < float > {public:typedef trueTypehasTrivalDefaultCtor;typedef trueTypehasTrivalCopyCtor;typedef trueTypehasTrivalAssignmentOperator;typedef trueTypehasTrivalDtor;typedef trueTypeisPODType;};template <> class typeTrait < double > {public:typedef trueTypehasTrivalDefaultCtor;typedef trueTypehasTrivalCopyCtor;typedef trueTypehasTrivalAssignmentOperator;typedef trueTypehasTrivalDtor;typedef trueTypeisPODType;};template <> class typeTrait < long double > {public:typedef trueTypehasTrivalDefaultCtor;typedef trueTypehasTrivalCopyCtor;typedef trueTypehasTrivalAssignmentOperator;typedef trueTypehasTrivalDtor;typedef trueTypeisPODType;};template <class type> class typeTrait < type* > {public:typedef trueTypehasTrivalDefaultCtor;typedef trueTypehasTrivalCopyCtor;typedef trueTypehasTrivalAssignmentOperator;typedef trueTypehasTrivalDtor;typedef trueTypeisPODType;};template <> class typeTrait < bool > {public:typedef trueTypehasTrivalDefaultCtor;typedef trueTypehasTrivalCopyCtor;typedef trueTypehasTrivalAssignmentOperator;typedef trueTypehasTrivalDtor;typedef trueTypeisPODType;};}#endif

#ifndef __VECTOR__H__#define __VECTOR__H__#pragma warning(disable : 4996)#include <memory>#include <string>#include <cassert>#include <algorithm>#include <stdexcept>#include "typeTrait.h"namespace stc{template <typename type,class Alloc = std::allocator<type> >class vector{public:typedeftypevalueType;typedef type*pointer;typedef type*iterator;typedef type&reference;typedef std::size_tsizeType;typedef std::ptrdiff_tdifferenceType;public:~vector();vector();vector(vector<type>&&);vector(const vector<type>&);vector(sizeType, const type&);vector(int, const type&);vector(long, const type&);explicit vector(sizeType);iterator begin() { return (mStart); }iterator end() { return (mFinish); }sizeType size() const{ return (mFinish - mStart); }sizeType capacity()const{ return (mEnd - mStart); }bool empty() const{ return mStart == mFinish; }reference operator[](sizeType index) { return *(mStart + index); }reference front() { assert(!empty()); return *mStart; }reference back() { assert(!empty()); return *(mFinish - 1); }void push_back(const type&);void pop_back();iterator erase(iterator, iterator);iterator erase(iterator);void clear();void insert(iterator,const type&,const sizeType = 1);vector<type>& operator =(const vector<type>&);vector<type>& operator =(vector<type>&&);vector<type>& memcopy(const vector<type>&);vector<type>& memcopy(vector<type>&&);private:void insertAux(const sizeType Sz = sDefaultSize);void insertAux(trueType,const sizeType Sz = sDefaultSize);void insertAux(falseType,const sizeType Sz = sDefaultSize);void deallocate();void fillInitialize(sizeType, const type&);void fillInitialize(sizeType, const type&, trueType);void fillInitialize(sizeType, const type&, falseType);void destroy(trueType) { mFinish = mStart; }void destroy(falseType);void push_back(const type&, trueType);void push_back(const type&, falseType);void pop_back(falseType);void pop_back(trueType);iterator erase(iterator, iterator, falseType);iterator erase(iterator, iterator, trueType);private:iteratormStart;iteratormFinish;iteratormEnd;AllocmAllocator;static const sizeTypesDefaultSize = 12;};template <typename type, class Alloc>vector<type, Alloc>::vector() :mStart(0), mFinish(0), mEnd(0){}template <typename type, class Alloc>vector<type, Alloc>::vector(sizeType Sz, const type& val): mStart(0), mFinish(0), mEnd(0){this->fillInitialize(Sz, val);}template <typename type, class Alloc>vector<type, Alloc>::vector(int Sz, const type& val): mStart(0), mFinish(0), mEnd(0){this->fillInitialize(Sz, val);}template <typename type, class Alloc>vector<type, Alloc>::vector(long Sz, const type& val): mStart(0), mFinish(0), mEnd(0){this->fillInitialize(Sz, val);}template <typename type, class Alloc>vector<type, Alloc>::vector(sizeType Sz): mStart(0), mFinish(0), mEnd(0){this->fillInitialize(Sz, type());}template <typename type,class Alloc>vector<type,Alloc>::vector(const vector<type>& rhs): mStart(0), mFinish(0), mEnd(0){*this = rhs;}template <typename type,class Alloc>vector<type,Alloc>::vector(vector<type>&& rhs): mStart(0), mFinish(0), mEnd(0){mStart = rhs.mStart;mFinish = rhs.mFinish;mEnd = rhs.mEnd;rhs.mStart = rhs.mFinish = mEnd = NULL;}template <typename type, class Alloc>vector<type, Alloc>::~vector(){typedef typename typeTrait<type>::isPODTypeisPODType;if (mStart != NULL){this->destroy(isPODType());mAllocator.deallocate(mStart, mEnd - mStart);}}template <typename type, class Alloc>void vector<type, Alloc>::fillInitialize(sizeType Sz, const type& val){assert(!mStart || !mEnd);mStart = mAllocator.allocate(Sz);if (mStart == NULL)throw std::bad_alloc();mFinish = mEnd = mStart + Sz;typedef typename typeTrait<type>::isPODTypeisPODType;this->fillInitialize(Sz, val, isPODType());}template <typename type, class Alloc>void vector<type, Alloc>::fillInitialize(sizeType Sz, const type& val, trueType){std::uninitialized_fill(mStrart, mStart + Sz, val);}template <> void vector<char>::fillInitialize(sizeType Sz, const char& ch, trueType){memset(mStart, ch, Sz);}template <> void vector<wchar_t>::fillInitialize(sizeType Sz, const wchar_t& wch, trueType){wmemset(mStart, wch, Sz);}template <typename type, class Alloc>void vector<type, Alloc>::fillInitialize(sizeType Sz, const type& val, falseType){std::uninitialized_fill(mStart, mStart + Sz, val);}template <typename type, class Alloc>void vector<type, Alloc>::deallocate(){assert(mStart);mAllocator.deallocate(mStart, mEnd - mStart);mStart = mFinish = mEnd = NULL;}template <typename type, class Alloc>void vector<type, Alloc>::insertAux(const sizeType Sz){typedef typename stc::typeTrait<type>::isPODTypeisPODType;this->insertAux(isPODType());}template <typename type, class Alloc>void vector<type, Alloc>::insertAux(trueType,const sizeType Sz){sizeType oSz = size();sizeType nSz = oSz + sDefaultSize;iterator ps = mAllocator.allocate(nSz);if (ps == NULL)throw std::bad_alloc();if (oSz != 0){std::copy(mStart, mStart + oSz, ps);mAllocator.deallocate(mStart, oSz);}mStart = ps;mEnd = mStart + nSz;mFinish = mStart + oSz;}template <typename type, class Alloc>void vector<type, Alloc>::insertAux(falseType,const sizeType Sz){sizeType oSz = size();sizeType nSz = oSz + Sz;iterator ps = mAllocator.allocate(nSz);if (ps == NULL)throw std::bad_alloc();std::uninitialized_copy(mStart, mEnd, ps);this->destroy(falseType());mAllocator.deallocate(mStart, oSz);mStart = ps;mFinish = mStart + oSz;mEnd = ps + nSz;}template <typename type, class Alloc>void vector<type, Alloc>::destroy(falseType){if (mStart == NULL) return;for (iterator first = mStart; first != mFinish; ++first)mAllocator.destroy(first);mFinish = mStart;}template <typename type, class Alloc>void vector<type, Alloc>::push_back(const type& val){if (mFinish == mEnd)this->insertAux();typedef typename stc::typeTrait<type>::isPODType isPODType;this->push_back(val, isPODType());}template <typename type, class Alloc>void vector<type, Alloc>::push_back(const type& val, falseType){mAllocator.construct(mFinish, val);++mFinish;}template <typename type,class Alloc>inline void vector<type,Alloc>::push_back(const type& val, trueType){*mFinish = val;++mFinish;}template <typename type,class Alloc>void vector<type,Alloc>::pop_back(){assert(mStart != mFinish);typedef typename stc::typeTrait<type>::isPODType isPODType;this->pop_back(isPODType());}template <typename type,class Alloc>inline void vector<type,Alloc>::pop_back(trueType){--mFinish;}template <typename type,class Alloc>void vector<type, Alloc>::pop_back(falseType){mAllocator.destroy(mFinish);--mFinish;}template <typename type,class Alloc>typename vector<type,Alloc>::iterator vector<type,Alloc>::erase(iterator first, iterator last){assert(first <= last);assert(last <= mFinish);typedef typename typeTrait<type>::isPODTypeisPODType;return erase(first, last, isPODType());}template <typename type,class Alloc>typename vector<type,Alloc>::iteratorvector<type, Alloc>::erase(iterator first, iterator last, falseType){iterator it = std::copy(last, mFinish, first);for (iterator iter = it; iter != mFinish; ++iter)mAllocator.destroy(iter);mFinish -= (last - first);return it;}template <typename type,class Alloc>typename vector<type,Alloc>::iteratorvector<type,Alloc>::erase(iterator first, iterator last, trueType){iterator it = std::copy(last, mFinish, first);mFinish -= (last - first);return it;}template <> typename vector<char>::iteratorvector<char>::erase(char* first, char* last, trueType){char* it = (char*)memcpy(first, last, mFinish - last);mFinish -= (last - first);return it;}template <typename type,class Alloc>typename vector<type,Alloc>::iteratorvector<type,Alloc>::erase(iterator pos){assert(pos >= mStart && pos < mFinish);return erase(pos, pos + 1);}template <typename type,class Alloc>void vector<type,Alloc>::clear(){if (empty()) return;erase(begin(), end());mStart = mEnd = mFinish = NULL;}template <typename type,class Alloc>void vector<type,Alloc>::insert(iterator pos, const type& val, const sizeType Sz){if (Sz == 0) return;assert(pos < this->mFinish);assert(pos >= mStart);if (capacity() >= Sz){sizeType elemAfter = mFinish - pos;sizeType pre = mFinish;if (elemAfter > Sz){std::uninitialized_copy(mFinish - Sz, mFinish, mFinish);mFinish += Sz;std::copy_backward(pos, pre - Sz, pre);std::fill(pos, pos + Sz, val);}else{std::uninitialized_copy_n(mFinish, Sz - elemAfter, val);mFinish += Sz - elemAfter;std::uninitialized_copy(pos, pre, pre);mFinish += elemAfter;std::fill(pos, pre, val);}}else{sizeType oSz = size();sizeType nSz = oSz + Sz;iterator nMemory = mAllocator.allocate(nSz);if (nMemory == NULL) throw std::bad_alloc();iterator nFinish = std::uninitialized_copy(mStart, pos, nMemory);nFinish = std::uninitialized_copy_n(nFinish, Sz, val);nFinish = std::uninitialized_copy(pos, mFinish, nFinish);this->clear();mStart = nMemory;mFinish = nFinish;mEnd = mStart + nSz;}}template <typename type,class Alloc>vector<type>& vector<type,Alloc>::operator =(const vector<type>& rhs){return this->memcopy(rhs);}template <typename type,class Alloc>vector<type>& vector<type,Alloc>::operator =(vector<type>&& rhs){if (this == (&rhs)) return *this;this->clear();mStart = rhs.mStart;mFinish = rhs.mFinish;mEnd = rhs.mEnd;rhs.mStart = rhs.mFinish = mEnd = NULL;}template <typename type,class Alloc>vector<type>& vector<type,Alloc>::memcopy(const vector<type>& rhs){if (this == (&rhs)) return *this;iterator nMemory = mAllocator.allocate(rhs.size());if (nMemory == NULL) throw std::bad_alloc();iterator it = std::uninitialized_copy(rhs.begin(),rhs.end(),nMemory);try{if (it != (nMemory + rhs.size())){mAlloc.deallocate(nMemory);std::runtime_error("");}}catch (const std::runtime_error& e){abort();}catch (...){}this->clear();mStart = nMemory;mFinish = mEnd = nMemory + rhs.size();return *this;}template <typename type,class Alloc>vector<type>& vector<type,Alloc>::memcopy(vector<type>&& rhs){if (this == (&rhs)) return *this;this->clear();mStart = rhs.mStart;mFinish = rhs.mFinish;mEnd = rhs.mEnd;rhs.mStart = rhs.mFinish = mEnd = NULL;}}#endif