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-16 11:19:55 +08:00
parent dd0f473995
commit 3e70e8db26
1 changed files with 168 additions and 11 deletions
Download Patch File Download Diff File Expand all files Collapse all files

179
TinySTL/Deque.h
View File

@@ -2,37 +2,169 @@
#define _DEQUE_H_
#include "Allocator.h"
#include "Iterator.h"
#include "ReverseIterator.h"
namespace TinySTL{
//class of deque iterator
class diter{};
template<class T, class Alloc = allocator<T>>
class deque;
namespace{
//class of deque iterator
template<class T>
class diter :public iterator<bidirectional_iterator_tag, T>{
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)
:mapIndex_(index), cur_(ptr), container_(container){}
diter(const diter& it)
:mapIndex_(it.mapIndex_), cur_(it.cur_), container_(it.container_){}
diter& operator = (const diter& it){
if (this != it){
mapIndex_ = it->mapIndex_;
cur_ = it->cur_;
container_ = it->container_;
}
return *this;
}
reference operator *(){ return *cur_; }
pointer operator ->(){ return &(operator*()); }
diter& operator ++(){
if (cur_ != getBuckTail(mapIndex_))//+1<><31><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͬһ<CDAC><D2BB>Ͱ<EFBFBD><CDB0>
++cur_;
else{
++mapIndex_;
cur_ = getBuckHead(mapIndex_);
}
return *this;
}
diter operator ++(int){
auto res = *this;
++(*this);
return res;
}
diter& operator --(){
if (cur_ != getBuckHead(mapIndex_))//<2F><>ǰ<EFBFBD><C7B0>ָ<EFBFBD><D6B8>Ͱͷ
--cur_;
else{
--mapIndex_;
cur_ = getBuckTail(mapIndex_);
}
return *this;
}
diter operator --(int){
auto res = *this;
--(*this);
return res;
}
bool operator ==(const diter& it)const{
return ((mapIndex_ == it.mapIndex_) &&
(cur_ == it.cur_) && (container_ == it.container_));
}
bool operator !=(const diter& it)const{
return !(*this == it);
}
private:
T *getBuckTail(size_t mapIndex)const{
return container_[mapIndex] + container_->getBuckSize() - 1;
}
T *getBuckHead(size_t mapIndex)const{
return container_->map_[mapIndex];
}
public:
template<class T>
friend diter<T> operator + (const diter<T>& it, typename diter<T>::difference_type n);
template<class T>
friend diter<T> operator + (typename diter<T>::difference_type n, const diter<T>& it);
template<class T>
friend diter<T> operator - (const diter<T>& it, typename diter<T>::difference_type n);
template<class T>
friend diter<T> operator - (typename diter<T>::difference_type n, const diter<T>& it);
template<class T>
friend typename diter<T>::difference_type operator - (const diter<T>& it1, const diter<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);
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;
}
else{
n = n - m;
res.mapIndex_ += n / res.container_->getBuckSize();
res.cur_ = res.getBuckHead(res.mapIndex_) + n % res.container_->getBuckSize();
}
return res;
}
template<class T>
diter<T> operator + (typename diter<T>::difference_type n, const diter<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);
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;
else{
n = n - m;
res.mapIndex_ -= n / res.container_->getBuckSize();
res.cur_ = res.getBuckTail(res.mapIndex_) - n % res.container_->getBuckSize();
}
return res;
}
template<class T>
diter<T> operator - (typename diter<T>::difference_type n, const diter<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)
+ (it1.cur_ - it1.getBuckHead(it1.mapIndex_)) + (it2.getBuckTail(it2.mapIndex_) - it2.cur_);
}
}
//class of deque
template<class T, class Alloc = TinySTL::allocator<T>>
template<class T, class Alloc>
class deque{
private:
template<class T>
friend class diter;
public:
typedef T value_type;
typedef diter iterator;
typedef diter<T> iterator;
typedef const iterator const_iterator;
typedef reverse_iterator<iterator> reverse_iterator;
typedef reverse_iterator<const_iterator> const_reverse_iterator;
typedef const reverse_iterator const_reverse_iterator;
typedef T& reference;
typedef const reference const_reference;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
typedef Alloc allocator_type;
private:
typedef Alloc dataAllocator;
T *bucks;
enum class EBucksSize{BUCKSIZE = 64};
private:
iterator beg_, end_;
size_t mapSize_;
T **map_;
public:
explicit deque(const allocator_type& alloc = allocator_type());
explicit deque(size_type n, const value_type& val = value_type(), const allocator_type& alloc = allocator_type());
deque();
explicit deque(size_type n, const value_type& val = value_type());
template <class InputIterator>
deque(InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type());
deque(InputIterator first, InputIterator last);
deque(const deque& x);
~deque();
~deque(){
for (int i = 0; i != mapSize_; ++i)
delete[] map_[i];
delete[] map_;
}
deque& operator= (const deque& x);
deque& operator= (deque&& x);
@@ -77,6 +209,20 @@ namespace TinySTL{
iterator erase(iterator first, iterator last);
void swap(deque& x);
void clear();
private:
T *getABuck(){
return new T[getBuckSize()];
}
T** getANewMap(const size_t size){
mapSize_ = getNewMapSize(size);
return new T*[mapSize_](0);
}
size_t getNewMapSize(const size_t size){
return (size == 0 ? 1 : size * 1.5);
}
size_t getBuckSize()const{
return EBucksSize::BUCKSIZE;
}
public:
template <class T, class Alloc>
friend bool operator== (const deque<T, Alloc>& lhs, const deque<T, Alloc>& rhs);
@@ -93,5 +239,16 @@ namespace TinySTL{
template <class T, class Alloc>
friend void swap(deque<T, Alloc>& x, deque<T, Alloc>& y);
};//end of deque
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>
//template <class InputIterator>
//deque<T, Alloc>::deque(InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type());
//template<class T, class Alloc>
//deque<T, Alloc>::deque(const deque& x);
}
#endif