先给出源代码
#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);
}