From 81b419cafec7988f1ca29a89ae74bb3fd0ba18e4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=82=B9=E6=99=93=E8=88=AA?= <1210603696@qq.com>
Date: Wed, 24 Sep 2014 14:36:37 +0800
Subject: [PATCH] =?UTF-8?q?bug=20fix=EF=BC=8C=E6=B7=BB=E5=8A=A0CB=E7=9A=84?=
 =?UTF-8?q?size=5F=E6=88=90=E5=91=98?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 TinySTL/CircularBuffer.h | 68 +++++++++++++++++++++++++++++++---------
 1 file changed, 54 insertions(+), 14 deletions(-)

diff --git a/TinySTL/CircularBuffer.h b/TinySTL/CircularBuffer.h
index 0c1daca..299f35a 100644
--- a/TinySTL/CircularBuffer.h
+++ b/TinySTL/CircularBuffer.h
@@ -5,13 +5,15 @@
 #include "Iterator.h"
 #include "UninitializedFunctions.h"
 
+#include <cassert>
+
 namespace TinySTL{
 	template<class T, size_t N, class Alloc>
 	class circular_buffer;
 	namespace{
 		//the iterator of circular buffer
 		template<class T, size_t N, class Alloc = allocator<T>>
-		class cb_iter:iterator<bidirectional_iterator_tag, T>{
+		class cb_iter:iterator<bidirectional_iterator_tag, T>{//bidirectional iterator
 		private:
 			typedef circular_buffer<T, N, Alloc> cb;
 			typedef cb *cbPtr;
@@ -25,9 +27,11 @@ namespace TinySTL{
 				ptr_(ptr), index_(ptr - container->start_), container_(container){}
 		public:
 			operator T*(){ return ptr_; }
+			T& operator *(){ return *ptr_; }
+			T *operator ->(){ return &(operator*()); }
 
 			cb_iter& operator ++(){
-				setIndex_(++index_ % N);
+				setIndex_(nextIndex(index_));
 				setPtr_(container_->start_ + index_);
 				return *this;
 			}
@@ -37,9 +41,7 @@ namespace TinySTL{
 				return temp;
 			}
 			cb_iter& operator --(){
-				int index = index_ - 1;
-				index = (index == -1 ? index + N : index);
-				setIndex_(index);
+				setIndex_(prevIndex(index_));
 				setPtr_(container_->start_ + index_);
 				return *this;
 			}
@@ -48,15 +50,37 @@ namespace TinySTL{
 				--(*this);
 				return temp;
 			}
+			bool operator == (const cb_iter& it)const{
+				return (container_ == it.container_) &&
+					(ptr_ == it.ptr_) && (index_ == it.index_);
+			}
+			bool operator != (const cb_iter& it)const{
+				return !((*this) == it);
+			}
+			/*bool operator <= (const cb_iter& it)const{
+				cb_iter cur = *this;
+				for (; cur != container_->last(); ++cur){
+					if (cur == it) return true;
+				}
+				return (cur == it ? true : false);
+			}*/
 		private:
 			void setIndex_(int index){ index_ = index; }
 			void setPtr_(T *ptr){ ptr_ = ptr; }
+			int nextIndex(int index){ return (++index) % N; }
+			int prevIndex(int index){
+				--index;
+				index = (index == -1 ? index + N : index);
+				return index;
+			}
 		};
 	}//end of anonymous namespace
 
 	//circular buffer
 	template<class T, size_t N, class Alloc = allocator<T>>
 	class circular_buffer{
+		template<class T, size_t N, class Alloc>
+		friend class cb_iter;
 	public:
 		typedef T			value_type;
 		typedef cb_iter<T, N>	iterator;
@@ -67,39 +91,52 @@ namespace TinySTL{
 	private:
 		T *start_;
 		T *finish_;
-		int indexOfHead;
+		int indexOfHead;//the first position
 		int indexOfTail;//the last position 
+		size_type size_;
 
 		typedef Alloc dataAllocator;
 	public:
 		circular_buffer() :
-			start_(0), finish_(0), indexOfHead(0), indexOfTail(0){}
+			start_(0), finish_(0), indexOfHead(0), indexOfTail(0), size_(0){}
 		explicit circular_buffer(const int& n, const value_type& val = value_type());
 		template<class InputIterator>
 		circular_buffer(InputIterator first, InputIterator last);
+		~circular_buffer(){
+			/*dataAllocator::destroy(start_, finish_);
+			dataAllocator::deallocate(start_, finish_);*/
+		}
 
-		bool full(){ return ((indexOfTail + 1) % N) == indexOfHead; }
-		bool empty(){ return indexOfHead == indexOfTail; }
+		bool full(){ return size_ == N; }
+		bool empty(){ return size_ == 0; }
+		difference_type capacity(){ return finish_ - start_; }
+		size_type size(){ return size_; }
 
 		//just for test
-		T *begin(){ return start_; }
-		T *end(){ return finish_; }
+		/*T *begin(){ return start_; }
+		T *end(){ return finish_; }*/
+		iterator first(){ return iterator(start_ + indexOfHead, this); }
+		iterator last(){ return iterator(start_ + indexOfTail, this); }
+
+		reference operator [](size_type i){ return *(start_ + i); }
 	private:
-		void allocateAndFillN(const int& n, const value_type& val){
+		void allocateAndFillN(const int& n, const value_type& val){//only for ctor
 			start_ = dataAllocator::allocate(N);
 			finish_ = start_ + N;
 			indexOfHead = 0;
 			if (N <= n){
 				finish_ = TinySTL::uninitialized_fill_n(start_, N, val);
 				indexOfTail = N - 1;
+				size_ = N;
 			}else{//N > n
 				finish_ = TinySTL::uninitialized_fill_n(start_, n, val);
 				finish_ = TinySTL::uninitialized_fill_n(finish_, N - n, value_type());
 				indexOfTail = n - 1;
+				size_ = n;
 			}
 		}
 		template<class InputIterator>
-		void allocateAndCopy(InputIterator first, InputIterator last){
+		void allocateAndCopy(InputIterator first, InputIterator last){//only for ctor
 			int n = last - first;
 			start_ = dataAllocator::allocate(N);
 			indexOfHead = 0;
@@ -112,14 +149,17 @@ namespace TinySTL{
 				indexOfTail = n - 1;
 			}
 		}
-	};
+		int nextIndex(int index){ return ++index % N; }
+	};//end of circular buffer
 	template<class T, size_t N, class Alloc>
 	circular_buffer<T, N, Alloc>::circular_buffer(const int& n, const value_type& val = value_type()){
+		assert(n != 0);
 		allocateAndFillN(n, val);
 	}
 	template<class T, size_t N, class Alloc>
 	template<class InputIterator>
 	circular_buffer<T, N, Alloc>::circular_buffer(InputIterator first, InputIterator last){
+		assert((last - first) >= 2);
 		allocateAndCopy(first, last);
 	}
 }