steven/TinySTL
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

精简deque的接口

Browse Source
This commit is contained in:
邹晓航
2014-10-22 14:57:46 +08:00
parent 3038262c6f
commit 3e1b456bed
1 changed files with 49 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files

109
TinySTL/Deque.h
View File

@@ -11,19 +11,22 @@ namespace TinySTL{
namespace{ namespace{
//class of deque iterator //class of deque iterator
template<class T> template<class T>
class diter :public iterator<bidirectional_iterator_tag, T>{ class dq_iter :public iterator<bidirectional_iterator_tag, T>{
private:
template<class T, class Alloc>
friend class deque;
private: private:
typedef TinySTL::deque<T>* cntrPtr; typedef TinySTL::deque<T>* cntrPtr;
size_t mapIndex_; size_t mapIndex_;
T *cur_; T *cur_;
cntrPtr container_; cntrPtr container_;
public: public:
diter() :mapIndex_(-1), cur_(0), container_(0){} dq_iter() :mapIndex_(-1), cur_(0), container_(0){}
diter(size_t index, T *ptr, cntrPtr container) dq_iter(size_t index, T *ptr, cntrPtr container)
:mapIndex_(index), cur_(ptr), container_(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_){} :mapIndex_(it.mapIndex_), cur_(it.cur_), container_(it.container_){}
diter& operator = (const diter& it){ dq_iter& operator = (const dq_iter& it){
if (this != it){ if (this != it){
mapIndex_ = it->mapIndex_; mapIndex_ = it->mapIndex_;
cur_ = it->cur_; cur_ = it->cur_;
@@ -33,7 +36,7 @@ namespace TinySTL{
} }
reference operator *(){ return *cur_; } reference operator *(){ return *cur_; }
pointer operator ->(){ return &(operator*()); } pointer operator ->(){ return &(operator*()); }
diter& operator ++(){ dq_iter& operator ++(){
if (cur_ != getBuckTail(mapIndex_))//+1<><31><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͬһ<CDAC><D2BB>Ͱ<EFBFBD><CDB0> if (cur_ != getBuckTail(mapIndex_))//+1<><31><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͬһ<CDAC><D2BB>Ͱ<EFBFBD><CDB0>
++cur_; ++cur_;
else{ else{
@@ -42,12 +45,12 @@ namespace TinySTL{
} }
return *this; return *this;
} }
diter operator ++(int){ dq_iter operator ++(int){
auto res = *this; auto res = *this;
++(*this); ++(*this);
return res; return res;
} }
diter& operator --(){ dq_iter& operator --(){
if (cur_ != getBuckHead(mapIndex_))//<2F><>ǰ<EFBFBD><C7B0>ָ<EFBFBD><D6B8>Ͱͷ if (cur_ != getBuckHead(mapIndex_))//<2F><>ǰ<EFBFBD><C7B0>ָ<EFBFBD><D6B8>Ͱͷ
--cur_; --cur_;
else{ else{
@@ -56,16 +59,16 @@ namespace TinySTL{
} }
return *this; return *this;
} }
diter operator --(int){ dq_iter operator --(int){
auto res = *this; auto res = *this;
--(*this); --(*this);
return res; return res;
} }
bool operator ==(const diter& it)const{ bool operator ==(const dq_iter& it)const{
return ((mapIndex_ == it.mapIndex_) && return ((mapIndex_ == it.mapIndex_) &&
(cur_ == it.cur_) && (container_ == it.container_)); (cur_ == it.cur_) && (container_ == it.container_));
} }
bool operator !=(const diter& it)const{ bool operator !=(const dq_iter& it)const{
return !(*this == it); return !(*this == it);
} }
private: private:
@@ -77,19 +80,19 @@ namespace TinySTL{
} }
public: public:
template<class T> template<class T>
friend diter<T> operator + (const diter<T>& it, typename diter<T>::difference_type n); friend dq_iter<T> operator + (const dq_iter<T>& it, typename dq_iter<T>::difference_type n);
template<class T> template<class T>
friend diter<T> operator + (typename diter<T>::difference_type n, const diter<T>& it); friend dq_iter<T> operator + (typename dq_iter<T>::difference_type n, const dq_iter<T>& it);
template<class T> template<class T>
friend diter<T> operator - (const diter<T>& it, typename diter<T>::difference_type n); friend dq_iter<T> operator - (const dq_iter<T>& it, typename dq_iter<T>::difference_type n);
template<class T> template<class T>
friend diter<T> operator - (typename diter<T>::difference_type n, const diter<T>& it); friend dq_iter<T> operator - (typename dq_iter<T>::difference_type n, const dq_iter<T>& it);
template<class T> template<class T>
friend typename diter<T>::difference_type operator - (const diter<T>& it1, const diter<T>& it2); friend typename dq_iter<T>::difference_type operator - (const dq_iter<T>& it1, const dq_iter<T>& it2);
}; };
template<class T> template<class T>
diter<T> operator + (const diter<T>& it, typename diter<T>::difference_type n){//assume n >= 0 dq_iter<T> operator + (const dq_iter<T>& it, typename dq_iter<T>::difference_type n){//assume n >= 0
diter<T> res(it); dq_iter<T> res(it);
auto m = res.getBuckTail(res.mapIndex_) - res.cur_; auto m = res.getBuckTail(res.mapIndex_) - res.cur_;
if (n <= m){//ǰ<><C7B0>n<EFBFBD><6E><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͬһ<CDAC><D2BB>Ͱ<EFBFBD><CDB0> if (n <= m){//ǰ<><C7B0>n<EFBFBD><6E><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͬһ<CDAC><D2BB>Ͱ<EFBFBD><CDB0>
res.cur_ += n; res.cur_ += n;
@@ -102,12 +105,12 @@ namespace TinySTL{
return res; return res;
} }
template<class T> template<class T>
diter<T> operator + (typename diter<T>::difference_type n, const diter<T>& it){ dq_iter<T> operator + (typename dq_iter<T>::difference_type n, const dq_iter<T>& it){
return (it + n); return (it + n);
} }
template<class T> template<class T>
diter<T> operator - (const diter<T>& it, typename diter<T>::difference_type n){//assume n >= 0 dq_iter<T> operator - (const dq_iter<T>& it, typename dq_iter<T>::difference_type n){//assume n >= 0
diter<T> res(it); dq_iter<T> res(it);
auto m = res.cur_ - res.getBuckHead(res.mapIndex_); auto m = res.cur_ - res.getBuckHead(res.mapIndex_);
if (n <= m)//<2F><><EFBFBD><EFBFBD>n<EFBFBD><6E><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͬһ<CDAC><D2BB>Ͱ<EFBFBD><CDB0> if (n <= m)//<2F><><EFBFBD><EFBFBD>n<EFBFBD><6E><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͬһ<CDAC><D2BB>Ͱ<EFBFBD><CDB0>
res.cur_ -= n; res.cur_ -= n;
@@ -119,12 +122,12 @@ namespace TinySTL{
return res; return res;
} }
template<class T> template<class T>
diter<T> operator - (typename diter<T>::difference_type n, const diter<T>& it){ dq_iter<T> operator - (typename dq_iter<T>::difference_type n, const dq_iter<T>& it){
return (it - n); return (it - n);
} }
template<class T> template<class T>
typename diter<T>::difference_type operator - (const diter<T>& it1, const diter<T>& it2){ typename dq_iter<T>::difference_type operator - (const dq_iter<T>& it1, const dq_iter<T>& it2){
return typename diter<T>::difference_type(it1.container_->getBuckSize()) * (it1.mapIndex_ - it2.mapIndex_ - 1) return typename dq_iter<T>::difference_type(it1.container_->getBuckSize()) * (it1.mapIndex_ - it2.mapIndex_ - 1)
+ (it1.cur_ - it1.getBuckHead(it1.mapIndex_)) + (it2.getBuckTail(it2.mapIndex_) - it2.cur_); + (it1.cur_ - it1.getBuckHead(it1.mapIndex_)) + (it2.getBuckTail(it2.mapIndex_) - it2.cur_);
} }
} }
@@ -134,13 +137,11 @@ namespace TinySTL{
class deque{ class deque{
private: private:
template<class T> template<class T>
friend class diter; friend class dq_iter;
public: public:
typedef T value_type; typedef T value_type;
typedef diter<T> iterator; typedef dq_iter<T> iterator;
typedef const iterator const_iterator; typedef const iterator const_iterator;
typedef reverse_iterator<iterator> reverse_iterator;
typedef const reverse_iterator const_reverse_iterator;
typedef T& reference; typedef T& reference;
typedef const reference const_reference; typedef const reference const_reference;
typedef size_t size_type; typedef size_t size_type;
@@ -162,31 +163,22 @@ namespace TinySTL{
~deque(){ ~deque(){
for (int i = 0; i != mapSize_; ++i) for (int i = 0; i != mapSize_; ++i)
delete[] map_[i]; dataAllocator::deallocate(map_[i], getBuckSize());
delete[] map_; delete[] map_;
} }
deque& operator= (const deque& x); deque& operator= (const deque& x);
deque& operator= (deque&& x); deque& operator= (deque&& x);
iterator begin(); iterator begin(){ return beg_; }
const_iterator begin() const; const_iterator begin() const{ return beg_; }
iterator end(); iterator end(){ return end_; }
const_iterator end() const; const_iterator end() const{return end_}
reverse_iterator rbegin(); const_iterator cbegin() const{ return beg_; }
const_reverse_iterator rbegin() const; const_iterator cend() const{ return end_; }
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;
size_type size() const; size_type size() const{ return end() - begin(); }
size_type max_size() const; bool empty() const{ return begin() == end(); }
void resize(size_type n, value_type val = value_type());
bool empty() const;
void shrink_to_fit();
reference operator[] (size_type n); reference operator[] (size_type n);
const_reference operator[] (size_type n) const; const_reference operator[] (size_type n) const;
@@ -201,27 +193,21 @@ namespace TinySTL{
void push_front(value_type&& val); void push_front(value_type&& val);
void pop_back(); void pop_back();
void pop_front(); void pop_front();
iterator insert(iterator position, const value_type& val);
void insert(iterator position, size_type n, const value_type& val);
template <class InputIterator>
void insert(iterator position, InputIterator first, InputIterator last);
iterator erase(iterator position);
iterator erase(iterator first, iterator last);
void swap(deque& x); void swap(deque& x);
void clear(); void clear();
private: private:
T *getABuck(){ T *getABuck(){
return new T[getBuckSize()]; return dataAllocator::allocate(getBuckSize);
} }
T** getANewMap(const size_t size){ T** getANewMap(const size_t size){
mapSize_ = getNewMapSize(size); mapSize_ = size;
return new T*[mapSize_](0); 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); return (size == 0 ? 1 : size * 1.5);
} }*/
size_t getBuckSize()const{ size_t getBuckSize()const{
return EBucksSize::BUCKSIZE; return (size_t)EBucksSize::BUCKSIZE;
} }
public: public:
template <class T, class Alloc> template <class T, class Alloc>
@@ -243,11 +229,14 @@ namespace TinySTL{
template<class T, class Alloc> template<class T, class Alloc>
deque<T, Alloc>::deque() deque<T, Alloc>::deque()
:mapSize_(0), map_(0){} :mapSize_(0), map_(0){}
//template<class T, class Alloc> template<class T, class Alloc>
//deque<T, Alloc>::deque(size_type n, const value_type& val = value_type(), const allocator_type& alloc = allocator_type()); deque<T, Alloc>::deque(size_type n, const value_type& val = value_type()){
auto nMap = n / getBuckSize() + 1 + 2;
map_ = getANewMap(nMap);
}
//template<class T, class Alloc> //template<class T, class Alloc>
//template <class InputIterator> //template <class InputIterator>
//deque<T, Alloc>::deque(InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type()); //deque<T, Alloc>::deque(InputIterator first, InputIterator last);
//template<class T, class Alloc> //template<class T, class Alloc>
//deque<T, Alloc>::deque(const deque& x); //deque<T, Alloc>::deque(const deque& x);
} }