c++沉思录笔记（15章代码）

先给出源代码

#ifndef SEQ_H_INCLUDED
#define SEQ_H_INCLUDED

template <typename T> class Seq_item;
template <typename T>
class Seq {
public:
	Seq();
	Seq(const T&, const Seq&);
	Seq(const Seq&);
	~Seq();
	Seq& operator=(const Seq&);
	T hd() const;								//返回当前item指向的data内容
	Seq t1() const;								//返回指向下一个结点的指针
	operator bool() const;
	//
	//15.3内容
	Seq<T>& operator++();						//将item指向后一个结点（会破坏原来的序列）
	Seq<T> operator++(int);						//同上
	Seq<T>& operator+=(const Seq<T>&);			//连接两个序列
	T operator*();
	Seq<T>& insert(const T&);					//头插入结点
	Seq<T>& flip();								//颠倒该链
private:
	Seq_item<T>* owntail();						//返回一条引用计数都为1的新链
	void destroy(Seq_item<T>*);
	Seq(Seq_item<T>* s);
	Seq_item<T>* item;
};
#include "Seq.cpp"
#endif

#include "Seq.h"
#include "Seq_item.h"

template <typename T>
Seq<T>::Seq(): item(0) { }

template <typename T>
Seq<T>::Seq(const T& t, const Seq<T>& x):
			item(new Seq_item(t, x.item)) { }

template <typename T>
Seq<T>::Seq(const Seq<T>& s): item(s.item) 
{ 
	if (item)
		++item->use; 
}

template <typename T>
Seq<T>::operator bool() const
{
	return item != 0;
}

template <typename T>
T Seq<T>::hd() const
{
	if(item)
		return item->data;
	else
		throw "hd of an empty Seq";
}

template <typename T>
Seq<T>::Seq(Seq_item<T>* s): item(s)  
{
	if (s)
		s->use++;
}

template <typename T>
Seq<T> Seq<T>::t1() const 
{
	if (item)
		return Seq<T>(item->next);
	else 
		throw "t1 of an empty Seq";
}

template <typename T>
Seq<T>& Seq<T>::operator=(const Seq<T>& s)
{
	if(s.item)
		s.item->use++;
	destroy(item);
	item = s.item;
	return *this;
}

template <typename T>
Seq<T>::~Seq()
{
	destroy(item);
}
// 15.2
// 销毁每个节点
template <typename T>
void Seq<T>::destroy(Seq_item<T>* item)
{
	while ( item && --item->use == 0 ){
		Seq_item<T>* next = item->next;
		delete item;
		item = next;
	}
}

//15.3内容 操作符重载
template <typename T>
Seq<T>& Seq<T>::operator++()
{
	if (item){
		Seq_item<T>*  p = item->next;
		if(p)
			p->use++;
		if(--item->use == 0)
			delete item;
		item = p;
	}
	return *this;
}
template <typename T>
Seq<T> Seq<T>::operator++(int)
{
	Seq<T> ret = *this;
	if (item) {
		--item->use;
		item = item->next;
		if (item)
			item->use++;
	}
	return ret;
}
template <typename T>
T Seq<T>::operator*()
{
	return hd();
}
template <typename T>
Seq<T>& Seq<T>::insert(const T& t)
{
	item = new Seq_item<T>(t, item);
	return *this;
}
//
// 15.4
/*
 *  owntail函数返回的是一条指向引用计数都为1的新序列的指针
 *  不需要整条链都复制，只从必要的部分开始复制
 */
 template <typename T>
Seq_item<T>* Seq<T>::owntail()
{
	if(item == 0)
		return 0;
	Seq_item<T>* i = item;
	Seq_item<T>** p = &item;
	while (i->use == 1) {
			if(i->next == 0)
				return i;
			p = &i->next;
			i = i->next;
	}
	/*
	 *  此时i指向第一个use!=1的项
	 *	复制从第一个use!=1的项开始
	 */
	*p = new Seq_item<T> (i->data);
	--i->use;
	i = i->next;
	Seq_item<T>* j = *p;
	
	//	i遍历旧的序列，j遍历新的序列
	while (i) {
			j->next = new Seq_item<T> (i->data);
			i = i->next;
			j = j->next;
	}
	return j;
}
template <typename T>
Seq<T>& Seq<T>::flip()
{
	if (item) {
			Seq_item<T>* k = owntail();
			Seq_item<T>* curr = item;
			Seq_item<T>* behind = 0;
			Seq_item<T>* ahead  = 0;
			/*
			 *  改变Seq_item的next指针
			 *  让它们指向前一个Seq_item
			 */
			while (curr) {
					ahead = curr->next;
					curr->next = behind;
					behind = curr;
					curr = ahead;
			}
				item = k;
	}
	return *this;
}
/
// 15.5
template <typename T>
Seq<T>& Seq<T>::operator+=(const Seq<T>& s)
{	
	// 连接之前颠倒现有序列
	flip();
	Seq_item<T>* k = owntail();
	Seq_item<T>* q = s.item;

	// 将新序列的各结点插入到原来的序列
	while (q) {
			insert(q->data);
			q = q->next;
	}
	flip();
	return *this;
}

#ifndef SEQ_ITEM_H_INCLUDED
#define SEQ_ITEM_H_INCLUDED

template <typename T> class Seq;
template <typename T>
class Seq_item {
	friend class Seq<T>;

	int use;
	const T data;
	Seq_item* next;

	Seq_item(const T& t, Seq_item<T>* s);
	Seq_item(const T& t);
};
#include "Seq_item.cpp"
#endif

#include "Seq_item.h"
template <typename T>
Seq_item<T>::Seq_item(const T& t): use(1), data(t), next(0) { }

template <typename T>
Seq_item<T>::Seq_item(const T& t, Seq_item<T>* s): 
use(1), data(t), next(s) 
{
	if (s)
		s->use++;
}

#include "iostream"
#include "Seq.h"
#include "Seq_item.h"
using namespace std;

template <typename T> Seq<T> cons(const T&, const Seq<T>&);
template <typename T> int length(Seq<T>);
template <typename T> Seq<T> merge(Seq<T>&, Seq<T>&);
template <typename T> Seq<T> operator+(Seq<T>, Seq<T>);

int main()
{
	Seq<int> s1,s2;
	//第一个序列s1
	for(int i = 0; i != 10;++i)
		s1.insert(10-i);
	Seq<int> b1 = s1;
	int length1 = length(b1);
	for(int i = 0; i != length1;++i)	{
		cout << *b1++ << "  ";
	}
	cout << endl;

	//第二个序列s2
	for(int i = 0; i != 10;++i)
		s2.insert(20-i);
	Seq<int> b2 = s2;
	int length2 = length(b2);
	for(int i = 0; i != length2;++i)	{
		cout << *b2++ << "  ";
	}
	cout << endl;
	
	//第三个序列s3（由s1、s2连接得来）
	Seq<int> s3 = s1 + s2;			//连接s1、s2
	Seq<int> b3 = s3;
	int length3 = length(b3);
	for(int i = 0; i != length3;++i)	{
		cout << *b3++ << "  ";
	}
	cout << endl;
	return 0;
}

template <typename T>
Seq<T> cons(const T& t, const Seq<T>& s)
{
	return Seq<T> (t, s);
}
template <typename T>
int length(Seq<T> s)
{
	int n = 0;
	while (s) {
		s = s.t1();
		++n;
	}
	return n;
}

// 15.4
template <typename T>
Seq<T> merge(Seq<T>& x, Seq<T>& y)
{
	Seq<T> r;

	while (x && y) {
		if (x.hd() < y.hd()){
			r.insert(x.hd());
			++x;
		}else {
			r.insert(y.hd());
			++y;
		}
	}
	while (x) {
		r.insert(x.hd());
		++x;
	}
	while (y) {
		r.insert(y.hd());
		++y;
	}
	r.flip();
	return r;
}
///
// 15.5
template <typename T>
Seq<T> operator+(Seq<T> s1, Seq<T> s2 )
{
	return s1.operator+=(s2);
}