template實現

#include <iostream>
using std::cout;
using std::endl;


/***************************************** deque ***************************************/


template <typename T>
class deque
{
public:

	//迭代器定義
	class iterator
	{
	public:
		iterator(int j = 0, T* a = 0, int sz = 0):maxsz(sz), i(j), arr(a) {}
		T& operator* () {return *(arr + i);}
		iterator& operator+= (int n) {i = (i + n) % maxsz; return *this;}
		iterator& operator-= (int n) {i = (i + maxsz - n%maxsz) % maxsz; return *this;}
		iterator operator+ (int n) const {iterator tmp = *this; return tmp += n;}
		iterator operator- (int n) const {iterator tmp = * this; return tmp -= n;}
		int operator- (const iterator& x) const {return (i + maxsz - x.i) % maxsz;}
		T& operator[] (int n) const {return *(*this + n);}
		bool operator!= (const iterator& rhs) {return i != rhs.i;}
		bool operator== (const iterator& rhs) {return i == rhs.i;}
		iterator& operator++() {i = (i + 1) % maxsz; return *this;}
		iterator operator++(int) {iterator tmp = *this;i = (i + 1) % maxsz; return tmp;}
		iterator& operator--() {i = (i + maxsz - 1) % maxsz; return *this;}
		iterator operator--(int) {iterator tmp = * this; i = (i + maxsz - 1) % maxsz; return tmp;}

	private:
		int maxsz, i;
		T *arr;
	};

	class const_iterator
	{
	public:
		const_iterator(int j = 0, T* a = 0, int sz = 0):maxsz(sz), i(j), arr(a) {}
		const T& operator* () {return *(arr + i);}
		const_iterator& operator+= (int n) {i = (i + n) % maxsz; return *this;}
		const_iterator& operator-= (int n) {i = (i + maxsz - n%maxsz) % maxsz; return *this;}
		const_iterator operator+ (int n) const {const_iterator tmp = *this; return tmp += n;}
		const_iterator operator- (int n) const {const_iterator tmp = * this; return tmp -= n;}
		int operator- (const const_iterator& x) const {return (i + maxsz - x.i) % maxsz;}
		const T& operator[] (int n) const {return *(*this + n);}
		bool operator!= (const const_iterator& rhs) {return i != rhs.i;}
		bool operator== (const const_iterator& rhs) {return i == rhs.i;}
		const_iterator& operator++() {i = (i + 1) % maxsz; return *this;}
		const_iterator operator++(int) {const_iterator tmp = *this;i = (i + 1) % maxsz; return tmp;}
		const_iterator& operator--() {i = (i + maxsz - 1) % maxsz; return *this;}
		const_iterator operator--(int) {const_iterator tmp = * this; i = (i + maxsz - 1) % maxsz; return tmp;}

	private:
		int maxsz, i;
		T *arr;
	};



public:
	deque(int size = 0, const T& value = T());
	deque(const deque<T>& rhs);
	~deque() {if (start) delete [] start;}
	deque<T>& operator=(const deque<T>& rhs);

	void resize(int n, const T& value = T());
	bool empty() const {return sz == 0;}
	int capacity() const {return maxsz;}
	int size() const {return sz;}
	void print_deque(std::ostream& out)const;

	T& back();
	const T& back() const;
	T& front();
	const T& front() const;
	void push_back(const T& item);
	void push_front(const T& item);
	void pop_back();
	void pop_front();

	T& operator[] (int i) {return start[(first + i) % maxsz];}
	const T& operator[] (int i) const {return start[(first + i) % maxsz];}

	//迭代器的函數接口
	iterator begin() {return iterator(first, start, maxsz);}
	iterator end() {return iterator(last, start, maxsz);}

	//const_iterator版本的begin()和end()重載不能用，不知道原因
	const_iterator begin()const {return const_iterator(first, start, maxsz);}
	const_iterator end()const {return const_iterator(last, start, maxsz);}

private:
	void reserve(int n, bool copy);		//分配空間

	T* start;	//內存起始地址
	int first, last;	//隊首、隊尾遊標
	int maxsz;	//分配空間大小
	int sz;		//元素個數



};

void no_mem()
{
	cout << "no_mem" << endl;
	exit(1);
}

void out_bounds()
{
	cout << "out_bounds" << endl;
	exit(2);
}

template <typename T>
void deque<T>::reserve(int n, bool copy)
{
	T *tmp = new T[n];
	if (tmp == NULL) no_mem();

	if (sz > n - 1) sz = n - 1;
	if (copy)
	{
		for (int i = 0; i < sz; ++i)
		{
			tmp[i] = start[(first + i) % maxsz];
		}
		last = sz;
	}
	if (start) delete [] start;
	start = tmp;
	first = 0;
	maxsz = n;
}

template <typename T>
deque<T>::deque(int size, const T& value):start(0), first(0), last(0), maxsz(0), sz(0)
{
	if (size == 0) return ;
	reserve(size + 1, false);
	
	for (int i = 0; i < size; ++i)
	{
		start[i] = value;
	}
}

template <typename T>
deque<T>::deque(const deque<T>& rhs):start(0), first(0), last(0), maxsz(0), sz(0)
{
	if (rhs.sz == 0) return ;
	reserve(rhs.sz + 1, false);
	for (int i = 0; i < rhs.sz; ++i)
	{
		start[i] = rhs.start[(rhs.first + i) % rhs.maxsz];
	}
	sz = rhs.sz;
	last = rhs.sz;
}

template <typename T>
T& deque<T>::back()
{
	if (sz == 0) out_bounds();
	return start[last - 1];
}

template <typename T>
const T& deque<T>::back() const
{
	if (sz == 0) out_bounds();
	return start[last - 1];
}

template <typename T>
T& deque<T>::front()
{
	if (sz == 0) out_bounds();
	return start[first];
}

template <typename T>
const T& deque<T>::front() const
{
	if (sz == 0) out_bounds();
	return start[first];
}

template <typename T>
void deque<T>::push_back(const T& item)
{
	if (sz == 0) reserve(2, false);
	else if (sz == maxsz - 1) reserve(2 * maxsz, true);
	start[last] = item;
	last = (last + 1) % maxsz;
	++ sz;
}

template <typename T>
void deque<T>::push_front(const T& item)
{
	if (sz == 0) reserve(2, false);
	else if (sz == maxsz - 1) reserve(2 * maxsz, true);
	first = (first + maxsz - 1) % maxsz;
	start[first] = item;
	++ sz;
}

template <typename T>
void deque<T>::pop_back()
{
	if (sz == 0) return out_bounds();
	last = (last + maxsz - 1) % maxsz;
	-- sz;
}

template <typename T>
void deque<T>::pop_front()
{
	if (sz == 0) return out_bounds();
	first = (first + 1) % maxsz;
	-- sz;
}

template <typename T>
void deque<T>::print_deque(std::ostream& out)const
{
	for(int i = 0; i < sz; ++i)
		cout << start[(first + i) % maxsz] << endl;
	cout << endl;
}

template <typename T>
std::ostream& operator<< (std::ostream& out, const deque<T>& rhs)
{
	rhs.print_deque(out);
	return out;
}

template <typename T>
void deque<T>::resize(int n, const T& value)
{
	reserve(n + 1, true);
	//int len = n - sz;
	if (n - sz > 0)
	{
		for (int i = sz; i <= n; ++i)
		{
			start[(first + i) % maxsz] = value;
		}
	}
	sz = n;
	last = sz;
}

template <typename T>
deque<T>& deque<T>::operator= (const deque<T>& rhs)
{
	if (&rhs == this) return *this;
	if (maxsz < rhs.sz) reserve(rhs.sz + 1, false);
	sz = rhs.sz;
	first = 0;
	last = sz;
	for (int i = 0; i < sz; ++i)
	{
		start[(first + i) % maxsz] = rhs.start[(rhs.first + i) % rhs.maxsz]; 
	}
	return *this;
}

/***************************************** end deque ********************************************/



#include <string>
using std::string;

int main(void)
{
	deque<int> deq;
	deq.push_back(1);
	deq.push_back(2);
	deq.push_back(3);
	deq.push_back(4);
	deq.push_back(5);
	
	deque<int>::iterator it = deq.begin();
	for (; it != deq.end(); ++it) 
		cout << *it <<endl;

	system("pause");
	return 0;
}