diff --git a/TinySTL/Deque.h b/TinySTL/Deque.h index 8408bc8..b99db2c 100644 --- a/TinySTL/Deque.h +++ b/TinySTL/Deque.h @@ -11,19 +11,22 @@ namespace TinySTL{ namespace{ //class of deque iterator template - class diter :public iterator{ + class dq_iter :public iterator{ + private: + template + friend class deque; private: typedef TinySTL::deque* cntrPtr; size_t mapIndex_; T *cur_; cntrPtr container_; public: - diter() :mapIndex_(-1), cur_(0), container_(0){} - diter(size_t index, T *ptr, cntrPtr container) + dq_iter() :mapIndex_(-1), cur_(0), container_(0){} + dq_iter(size_t index, T *ptr, cntrPtr container) :mapIndex_(index), cur_(ptr), container_(container){} - diter(const diter& it) + dq_iter(const dq_iter& it) :mapIndex_(it.mapIndex_), cur_(it.cur_), container_(it.container_){} - diter& operator = (const diter& it){ + dq_iter& operator = (const dq_iter& it){ if (this != it){ mapIndex_ = it->mapIndex_; cur_ = it->cur_; @@ -33,7 +36,7 @@ namespace TinySTL{ } reference operator *(){ return *cur_; } pointer operator ->(){ return &(operator*()); } - diter& operator ++(){ + dq_iter& operator ++(){ if (cur_ != getBuckTail(mapIndex_))//+1后还在同一个桶里 ++cur_; else{ @@ -42,12 +45,12 @@ namespace TinySTL{ } return *this; } - diter operator ++(int){ + dq_iter operator ++(int){ auto res = *this; ++(*this); return res; } - diter& operator --(){ + dq_iter& operator --(){ if (cur_ != getBuckHead(mapIndex_))//当前不指向桶头 --cur_; else{ @@ -56,16 +59,16 @@ namespace TinySTL{ } return *this; } - diter operator --(int){ + dq_iter operator --(int){ auto res = *this; --(*this); return res; } - bool operator ==(const diter& it)const{ + bool operator ==(const dq_iter& it)const{ return ((mapIndex_ == it.mapIndex_) && (cur_ == it.cur_) && (container_ == it.container_)); } - bool operator !=(const diter& it)const{ + bool operator !=(const dq_iter& it)const{ return !(*this == it); } private: @@ -77,19 +80,19 @@ namespace TinySTL{ } public: template - friend diter operator + (const diter& it, typename diter::difference_type n); + friend dq_iter operator + (const dq_iter& it, typename dq_iter::difference_type n); template - friend diter operator + (typename diter::difference_type n, const diter& it); + friend dq_iter operator + (typename dq_iter::difference_type n, const dq_iter& it); template - friend diter operator - (const diter& it, typename diter::difference_type n); + friend dq_iter operator - (const dq_iter& it, typename dq_iter::difference_type n); template - friend diter operator - (typename diter::difference_type n, const diter& it); + friend dq_iter operator - (typename dq_iter::difference_type n, const dq_iter& it); template - friend typename diter::difference_type operator - (const diter& it1, const diter& it2); + friend typename dq_iter::difference_type operator - (const dq_iter& it1, const dq_iter& it2); }; template - diter operator + (const diter& it, typename diter::difference_type n){//assume n >= 0 - diter res(it); + dq_iter operator + (const dq_iter& it, typename dq_iter::difference_type n){//assume n >= 0 + dq_iter res(it); auto m = res.getBuckTail(res.mapIndex_) - res.cur_; if (n <= m){//前进n步仍在同一个桶中 res.cur_ += n; @@ -102,12 +105,12 @@ namespace TinySTL{ return res; } template - diter operator + (typename diter::difference_type n, const diter& it){ + dq_iter operator + (typename dq_iter::difference_type n, const dq_iter& it){ return (it + n); } template - diter operator - (const diter& it, typename diter::difference_type n){//assume n >= 0 - diter res(it); + dq_iter operator - (const dq_iter& it, typename dq_iter::difference_type n){//assume n >= 0 + dq_iter res(it); auto m = res.cur_ - res.getBuckHead(res.mapIndex_); if (n <= m)//后退n步还在同一个桶中 res.cur_ -= n; @@ -119,12 +122,12 @@ namespace TinySTL{ return res; } template - diter operator - (typename diter::difference_type n, const diter& it){ + dq_iter operator - (typename dq_iter::difference_type n, const dq_iter& it){ return (it - n); } template - typename diter::difference_type operator - (const diter& it1, const diter& it2){ - return typename diter::difference_type(it1.container_->getBuckSize()) * (it1.mapIndex_ - it2.mapIndex_ - 1) + typename dq_iter::difference_type operator - (const dq_iter& it1, const dq_iter& it2){ + return typename dq_iter::difference_type(it1.container_->getBuckSize()) * (it1.mapIndex_ - it2.mapIndex_ - 1) + (it1.cur_ - it1.getBuckHead(it1.mapIndex_)) + (it2.getBuckTail(it2.mapIndex_) - it2.cur_); } } @@ -134,13 +137,11 @@ namespace TinySTL{ class deque{ private: template - friend class diter; + friend class dq_iter; public: typedef T value_type; - typedef diter iterator; + typedef dq_iter iterator; typedef const iterator const_iterator; - typedef reverse_iterator reverse_iterator; - typedef const reverse_iterator const_reverse_iterator; typedef T& reference; typedef const reference const_reference; typedef size_t size_type; @@ -162,31 +163,22 @@ namespace TinySTL{ ~deque(){ for (int i = 0; i != mapSize_; ++i) - delete[] map_[i]; + dataAllocator::deallocate(map_[i], getBuckSize()); delete[] map_; } deque& operator= (const deque& x); deque& operator= (deque&& x); - iterator begin(); - const_iterator begin() const; - iterator end(); - const_iterator end() const; - reverse_iterator rbegin(); - const_reverse_iterator rbegin() const; - reverse_iterator rend(); - const_reverse_iterator rend() const; - const_iterator cbegin() const; - const_iterator cend() const; - const_reverse_iterator crbegin() const; - const_reverse_iterator crend() const; + iterator begin(){ return beg_; } + const_iterator begin() const{ return beg_; } + iterator end(){ return end_; } + const_iterator end() const{return end_} + const_iterator cbegin() const{ return beg_; } + const_iterator cend() const{ return end_; } - size_type size() const; - size_type max_size() const; - void resize(size_type n, value_type val = value_type()); - bool empty() const; - void shrink_to_fit(); + size_type size() const{ return end() - begin(); } + bool empty() const{ return begin() == end(); } reference operator[] (size_type n); const_reference operator[] (size_type n) const; @@ -201,27 +193,21 @@ namespace TinySTL{ void push_front(value_type&& val); void pop_back(); void pop_front(); - iterator insert(iterator position, const value_type& val); - void insert(iterator position, size_type n, const value_type& val); - template - void insert(iterator position, InputIterator first, InputIterator last); - iterator erase(iterator position); - iterator erase(iterator first, iterator last); void swap(deque& x); void clear(); private: T *getABuck(){ - return new T[getBuckSize()]; + return dataAllocator::allocate(getBuckSize); } T** getANewMap(const size_t size){ - mapSize_ = getNewMapSize(size); + mapSize_ = size; return new T*[mapSize_](0); } - size_t getNewMapSize(const size_t size){ + /*size_t getNewMapSize(const size_t size){ return (size == 0 ? 1 : size * 1.5); - } + }*/ size_t getBuckSize()const{ - return EBucksSize::BUCKSIZE; + return (size_t)EBucksSize::BUCKSIZE; } public: template @@ -243,11 +229,14 @@ namespace TinySTL{ template deque::deque() :mapSize_(0), map_(0){} - //template - //deque::deque(size_type n, const value_type& val = value_type(), const allocator_type& alloc = allocator_type()); + template + deque::deque(size_type n, const value_type& val = value_type()){ + auto nMap = n / getBuckSize() + 1 + 2; + map_ = getANewMap(nMap); + } //template //template - //deque::deque(InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type()); + //deque::deque(InputIterator first, InputIterator last); //template //deque::deque(const deque& x); }