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{
//class of deque iterator
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:
typedef TinySTL::deque<T>* 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<><31><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͬһ<CDAC><D2BB>Ͱ<EFBFBD><CDB0>
++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_))//<2F><>ǰ<EFBFBD><C7B0>ָ<EFBFBD><D6B8>Ͱͷ
--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<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>
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>
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>
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>
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>
diter<T> operator + (const diter<T>& it, typename diter<T>::difference_type n){//assume n >= 0
diter<T> res(it);
dq_iter<T> operator + (const dq_iter<T>& it, typename dq_iter<T>::difference_type n){//assume n >= 0
dq_iter<T> res(it);
auto m = res.getBuckTail(res.mapIndex_) - res.cur_;
if (n <= m){//ǰ<><C7B0>n<EFBFBD><6E><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͬһ<CDAC><D2BB>Ͱ<EFBFBD><CDB0>
res.cur_ += n;
@@ -102,12 +105,12 @@ namespace TinySTL{
return res;
}
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);
}
template<class T>
diter<T> operator - (const diter<T>& it, typename diter<T>::difference_type n){//assume n >= 0
diter<T> res(it);
dq_iter<T> operator - (const dq_iter<T>& it, typename dq_iter<T>::difference_type n){//assume n >= 0
dq_iter<T> res(it);
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>
res.cur_ -= n;
@@ -119,12 +122,12 @@ namespace TinySTL{
return res;
}
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);
}
template<class T>
typename diter<T>::difference_type operator - (const diter<T>& it1, const diter<T>& it2){
return typename diter<T>::difference_type(it1.container_->getBuckSize()) * (it1.mapIndex_ - it2.mapIndex_ - 1)
typename dq_iter<T>::difference_type operator - (const dq_iter<T>& it1, const dq_iter<T>& it2){
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_);
}
}
@@ -134,13 +137,11 @@ namespace TinySTL{
class deque{
private:
template<class T>
friend class diter;
friend class dq_iter;
public:
typedef T value_type;
typedef diter<T> iterator;
typedef dq_iter<T> iterator;
typedef const iterator const_iterator;
typedef reverse_iterator<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 <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 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 <class T, class Alloc>
@@ -243,11 +229,14 @@ namespace TinySTL{
template<class T, class Alloc>
deque<T, Alloc>::deque()
:mapSize_(0), map_(0){}
//template<class T, class Alloc>
//deque<T, Alloc>::deque(size_type n, const value_type& val = value_type(), const allocator_type& alloc = allocator_type());
template<class T, class Alloc>
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 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>
//deque<T, Alloc>::deque(const deque& x);
}