c++模板实现自定义链表及操作

今天花时间整理了一下C++模板方面的知识，搞了一个小程序作为实践

下面是头文件：chain.h

#include <iostream>
using namespace std;

template <class T> class Chain;

template <class T>
class ChainNode {
friend class Chain<T>;
private:
	T data;
	ChainNode<T> *link;
};

template<class T>
class Chain{
public:
	Chain() {first = 0;}
	~Chain() ;
	bool IsEmpty() const {return first == 0;}
	int Length() const;
	bool Find(int k, T& x) const;
	int Search(const T& x) const;
	void Erase();
	Chain<T>& Append(const T& x);
	Chain<T>& Delete(int k, T& x);
	Chain<T>& Insert(int k, const T& x);
	void Output(ostream& out) const;
private:
	ChainNode<T> *first; //指向第一个节点的指针
};

class OutOfBounds  
{  
public:
        // 构造函数,参数为错误代码  
        OutOfBounds(int errorId)  
        {  
            // 输出构造函数被调用信息  
            std::cout << "MyExcepction is called" << std::endl;  
            m_errorId = errorId;  
        }  
 
        // 拷贝构造函数  
        OutOfBounds( OutOfBounds& myExp)  
        {  
            // 输出拷贝构造函数被调用信息  
            std::cout << "copy construct is called" << std::endl;  
            this->m_errorId = myExp.m_errorId;  
        }  
 
       ~OutOfBounds()  
        {  
            // 输出析构函数被调用信息  
            std::cout << "~MyExcepction is called" << std::endl;  
        }  
 
       // 获取错误码  
        int getErrorId()  
        {  
            return m_errorId;  
        }  
 
private:      
        // 错误码  
        int m_errorId;  
};  

以下是源文件：chain.cpp

#include "chain.h"

template<class T>
Chain<T>::~Chain( )
{	
	//链表的析构函数，用于删除链表中的所有节点
	ChainNode<T> *next; //下一个节点
	while (first) {
		next = first->link;
		delete first;
		first = next;
	}
}

template<class T>
int Chain<T>::Length() const
{
	//返回链表中的元素总数
	ChainNode<T> *current = first;
	int len = 0;
	while (current) {
		len++;
		current = current->link;
	}
	return len;
}

template<class T>
bool Chain<T>::Find(int k, T& x) const
{
//寻找链表中的第 k个元素，并将其传送至 x
//如果不存在第 k个元素，则返回false，否则返回true
	if (k < 1) return false;
	ChainNode<T> *current = first;
	int index = 1; // current 的索引
	while (index < k && current) {
		current = current->link;
		index++;
	}
	
	if (current) {x = current->data; return true;}
	return false; //  不存在第k个元素
}

template<class T>
int Chain<T>::Search(const T& x) const
{
	//寻找x，如果发现x，则返回x的地址
	//如果x不在链表中，则返回 0
	ChainNode<T> *current = first;
	int index = 1; // current 的索引
	while (current && current->data != x) {
		current = current->link;
		index++;
	}
	
	if (current) return index;
	return 0;
}

template<class T>
void Chain<T>::Output(ostream& out) const
{
	//将链表元素送至输出流
	ChainNode<T> *current;
	for (current = first; current; current = current->link)
	out << current->data << " ";
}

//重载<<
template <class T>
ostream& operator<<(ostream& out, const Chain<T>& x)
{
	x.Output(out);
	return out;
}

template<class T>
Chain<T>& Chain<T>::Delete(int k, T& x)
{
	//把第k个元素取至x，然后从链表中删除第 k个元素
	//如果不存在第 k个元素，则引发异常 OutOfBounds 
	if (k < 1 || !first)
		throw new OutOfBounds(-1); // 不存在第k个元素
	//p最终将指向第 k个节点
	ChainNode<T> *p = first;
	//将p移动至第k个元素，并从链表中删除该元素
	if (k == 1){ //p已经指向第k个元素
		first = first->link; //  删除之
	} else { //用q指向第k - 1个元素
		ChainNode<T> *q = first;	
		for (int index = 1; index < k - 1 && q; index++) {
			q = q->link;
		}
	
		if (!q || !q->link) {
			throw new OutOfBounds(-2); //不存在第k个元素
		}
		p = q->link; //存在第k个元素
		q->link = p->link; //从链表中删除该元素
	}
	//保存第k个元素并释放节点p
	x = p->data;
	delete p;
	return *this;
}

template<class T>
Chain<T>& Chain<T>::Insert(int k, const T& x)
{
	//在第k个元素之后插入x
	//如果不存在第 k个元素，则引发异常OutofBounds
	//如果没有足够的空间，则传递NoMem异常
	if (k < 0) throw new OutOfBounds(-1);
	//p最终将指向第 k个节点
	ChainNode<T> *p = first;
	//将p移动至第k个元素
	for (int index = 1; index < k && p; index++) 
		p = p->link;
	if (k > 0 && !p) throw new OutOfBounds(-1); //不存在第k个元素
	//插入
	ChainNode<T> *y=new ChainNode<T>;
	y->data = x;
	if (k)
	{//在p之后插入
		y->link = p->link;
		p->link = y;
	}
	else {//作为第一个元素插入
		y->link = first;
		first = y;
	}
	
	return *this;
}

template<class T>
void Chain<T>::Erase()
{
	//删除链表中的所有节点
	ChainNode<T> *next;
	while (first) {
		next = first->link;
		delete first;
		first = next;
	}
}

template <class T>
Chain<T>& Chain<T>::Append(const T& x)
{
	//在链表尾部添加x
	ChainNode<T> *y;
	ChainNode<T> *last;
	y = new ChainNode<T>;
	y->data = x;
	y->link = 0;
	last = first;
	if (first) {//链表非空
		while(last->link){
			last = last->link;
		}
		
		last->link = y;
		last = y;
	} else {//链表为空
		first = last = y;
	}
	
	return *this;
}

template<class T>
class ChainIterator {
public:
	T* Initialize(const Chain<T>& c)
	{
		location = c.first;
		if (location) 
			return &location->data;
		return 0;
	}
	
	T* Next()
	{
		if (!location)
			return 0;
		location = location->link;
		
		if (location) 
			return &location->data;
		return 0;
	}
	
private:
	ChainNode<T> *location;
};


int main(int argc, char **argv)
{
	Chain<int> intChain;
	int x = 5;
	intChain.Append(x);
	intChain.Append(1);
	intChain.Append(2);
	cout<<"after append:"<<intChain;
	intChain.Delete(intChain.Length(), x);
	cout<<std::endl<<x<<" was deleted"<<std::endl;
	cout<<"after delete:"<<intChain<<endl;
	intChain.Append(9);
	cout<<"after append:"<<intChain<<endl;
	intChain.Insert(3, 15);
	cout<<"after insert(3, 15):"<<intChain<<endl;
	cout<<"chain test"<<std::endl;
	return 0;
}

编译：g++ -o chain chain.cpp chain.h

运行：./chain

结果：

after append:5 1 2 
2 was deleted
after delete(intChain.Length()):5 1 
after append:5 1 9 
after insert(3, 15):5 1 9 15 
chain test