链表类，亲自测试使用成员方法

#include <iostream>
#include <stdexcept>
using namespace std;

typedef int T;
class List
{
private:
	struct Node
	{
		T data;
		Node* next;
		Node(const T& d):data(d),next()
		{

		}
	};
	Node* head;
	int sz;
	Node*& getptr(int pos);
public:
	List():head(),sz()
	{

	}
	
	~List()
	{
		clear();
	}

	List& insert(const T& d,int pos = 0);
	void travel();
	void clear();
	bool erase(int pos);
	void remove(const T& d);
	bool set(const T& d,int pos);
	int find(const T& d);
	int size()
	{
		return sz;
	}

	T& at(int pos);
	void push_front(const T& d)
	{
		insert(d,0);
	}
	
	void push_back(const T& d)
	{
		insert(d,sz);
	}

	void pop_front()
	{
		erase(0);
	}

	void pop_back()
	{
		erase(sz-1);
	}
};

List::Node*& List::getptr(int pos)
{
	if(pos < 0 || pos > sz)
	{
		pos = 0;
	}
	if(pos == 0) 
	{
		return head;
	}

	Node* p = head;
	
	for(int i = 0; i < pos -1 ; i++)
	{
		p = p->next;
	}
	
	return p->next;
}

List& List::insert(const T& d,int pos)
{
	Node* pn = new Node(d);
	Node*& ptr = getptr(pos);
	pn->next = ptr;
	ptr = pn;
	sz++;
	return *this;
}

void List::travel()
{
	Node* p = head;
	while(p)
	{
		cout << p->data << ' ' ;
		p = p->next;
	}
	cout << endl;
}

void List::clear()
{
	Node* p = head;
	while(head)
	{
		head = head->next;
		delete p;
		p = head;
	}
	sz = 0;
}

bool List::erase(int pos)
{
	if(pos < 0 || pos >= sz)
	{
		return false;
	}
	Node*& ptr = getptr(pos);
	Node* p = ptr;
	ptr = ptr->next;
	delete p;
	sz--;
	return true;
}

int List::find(const T& d)
{
	int pos = 0;
	Node* p = head;
	while(p)
	{
		if(p->data == d)
		{
			return pos;
		}
		//曾经把下面两行写入了if
		p = p->next;
		pos++;
	}
	return -1;
}

void List::remove(const T& d)
{
	int pos;
	while((pos = find(d)) != -1)
	{
		erase(pos);
	}
}

bool List::set(const T& d,int pos)
{
	if(pos < 0 || pos >= sz)
	{
		return false;
	}

	Node*& ptr = getptr(pos);
	ptr->data = d;
	return true;
}

T& List::at(int pos)
{
	if(pos < 0 || pos >= sz)
	{
		throw out_of_range("out");
	}
	//曾把下两句写到了if
	Node*& ptr = getptr(pos);	
	return ptr->data;
}

int main()
{
	List list;

	//单个insert、travel测试
	list.insert(111);
	list.travel();	

	//批量insert、travel测试
	list.insert(222);
	list.insert(333);
	list.insert(444);
	list.travel();
	
	//链表长度
	cout << "链表长度:" << list.size() << endl;

	//删除指定位置元素、travel
	list.remove(444);
	list.erase(2);
	list.travel();
	cout << "链表长度:" << list.size() << endl;

	//这里曾写为 list.set(123,2);但是很明显，这个2是从0开始数的
	//而这里经过2次删除，已经剩下2个，也就是0位置和1位置，so……
	list.set(123,1);	
	list.travel();
	
	//下面这条语句证明了上面两条语句里位置，其实我很懒，只是运行结果来推测
	cout << "123的位置" << list.find(123) << endl;

	//at函数
	cout << "位置1的元素的值：" << list.at(1) << endl;

	//从表头插入元素
	cout << "表头插入112" << endl;
	list.push_front(112);
	list.travel();

	//表尾插入元素
	cout << "表尾插入221" << endl;
	list.push_back(221);
	list.travel();

	//删除表头元素
	cout << "删除表头元素" << endl;
	list.pop_front();
	list.travel();

	//删除表尾元素
	cout << "删除表尾元素" << endl;
	list.pop_back();
	list.travel();

	//清除链表、travel测试
	list.clear();
	cout << "表已经清空了，看吧：" << endl;
	list.travel();
	
	cout << "OK,所有成员方法已经使用了个遍。结束" << endl;

}
/*
111 
444 333 222 111 
链表长度:4
333 222 
链表长度:2
333 123 
123的位置1
位置1的元素的值：123
表头插入112
112 333 123 
表尾插入221
112 333 123 221 
删除表头元素
333 123 221 
删除表尾元素
333 123 
表已经清空了，看吧：

OK,所有成员方法已经使用了个遍。结束
*/