C++ 造房子list

#pragma once

template<typename T>
class Clist
{
public:
	Clist();
	~Clist();
	Clist(const T *data);
	Clist(const Clist &ls);
	bool Push_bak(  T *const data);//后插
	bool Push_first(T*const data);//前插
	bool Push_bak(const int& pos,  T *const data);//定位插入
	const  T * const Pop_bak() ;//后
	const T *const Pop_first() ;//前
	T *Head_Top()const ;//返回顶部元素
	T *Edn_Top()const;//尾部元素
	T *findval(const T &fin_val)const;//返回朝找的元素
	void out_show()const;//显示所有元素
	void out_show_reverse()const;
	bool close();//清空
	bool empty();//是否为空
	size_t getLen(){ return len; }
	bool deleteVal(const T &data);//删除摸个元素
private:
	class Node
	{
	public:
		Node() :data(NULL), base(NULL), pNext(NULL){}
		Node(T *const m_data, Node *m_base);
		Node *getPNext()const;
		Node *getBase()const;
		void SetPNext(Node * m_pNext);
		void SetBase(Node *  m_base);
		T *getData()const;
		void SetData( T *const data);
	private:
		T *data;
		Node *pNext;
		Node *base;
	}*head,*end;
	size_t len;
};

#include "Clist.h"
#include <iostream>


template <typename T>
Clist<T>::Node::Node(T *const m_data, Node *m_base) :data(m_data), base(m_base)
{

}
template<typename T>
typename Clist<T>::Node *Clist<T>::Node::getPNext()const
{
	return pNext;
}
template<typename T>
typename Clist<T>::Node *Clist<T>::Node::getBase()const
{
	return base;
}
template<typename T>
void Clist<T>::Node::SetPNext(Node * m_pNext)
{
	pNext = m_pNext;
}
template<typename T>
void Clist<T>::Node::SetBase(Node *  m_base)
{
	base = m_base;
}

template<typename T>
T *Clist<T>::Node::getData()const
{
	return data;
}

template<typename T>
void Clist<T>::Node::SetData(T *const data)
{
	this->data = data;
}

template<typename T>
Clist<T>::Clist() :head(NULL), end(NULL), len(0)
{
}



template<typename T>
Clist<T>::~Clist()
{
	if (head)
	{
		close();
	}
}

template<typename T>
Clist<T>::Clist(const Clist<T> &ls)
{
	len = ls.getLen();

	Node *temp = ls.head;
	head = new Node((temp->getData()), NULL);
	end = head;
	temp = temp->getPNext();
	while (temp)
	{
		end->SetPNext(new Node(temp->getPNext(), end));
		end = end->getPNext();
		temp = temp->getPNext();
	}


}


template<typename T>
Clist<T>::Clist(const T *data) : head(NULL), end(NULL), len(0)
{
	if (!head&&data)
	{
		head = new Node(data, head);
		end = head;
		len++;
	}
	else
	{
	}
}


template<typename T>
bool Clist<T>::Push_bak(T *const data)
{
	if (!data)
		return false;
	if (!head)
	{
		head = new Node(data, head);
		end = head;
		len++;
		return true;
	}
	Node *pNew = new Node(data, end);
	end->SetPNext(pNew);
	end = pNew;
	len++;
	return true;
}
template<typename T>
bool Clist<T>::Push_first(T*const data)
{
	if (!data)
		return false;
	if (!head)
	{
		head = new Node(data, head);
		end = head;
		len++;
		return true;
	}
	Node *pNew = new Node(data, NULL);
	head->SetBase(pNew);
	pNew->SetPNext(head);
	head = pNew;
	len++;
	return true;

}


template<typename T>
bool Clist<T>::Push_bak(const int &pos, T *const data)
{
	if (pos<0 || pos>len - 1)
		return false;
	int tmplen = 0;
	Node *temp = head;
	while (tmplen < pos)
	{
		temp = temp->getPNext();
		tmplen++;
	}
	Node *pNew = new Node(data, temp->getBase());
	pNew->SetPNext(temp);
	temp->SetBase(pNew);
	len++;
	return true;
}


template<typename T>
const T * const Clist<T>::Pop_bak()
{
	if (!head)
	{
	}
	else
	{
		if (head == end)
		{
			T *temp = head->getData();
			delete head;
			end = head = NULL;
			len--;
			return temp;
		}
		T *temp = end->getData();

		Node *ptmp = end->getBase();
		ptmp->SetPNext(NULL);
		delete end;
		end = ptmp;
		len--;
		return temp;
	}
}

template<typename T>
const T *const Clist<T>::Pop_first()
{
	if (!head)
	{
	}
	else
	{
		if (head == end)
		{
			T *temp = head->getData();
			delete head;
			head = end = 0;
			len--;
			return temp;
		}
		T *temp = head->getData();
		head = head->getPNext();
		delete head->getBase<span style="font-family: Arial, Helvetica, sans-serif;">();</span>
		head->SetBase(NULL);
		len--;
		return temp;
	}

}


template<typename T>
T *Clist<T>::Head_Top()const
{
	if (!head)//不处理任意崩溃
	{
		return NULL;
	}
	else
	{
		return  head->getData();
	}
}
template<typename T>
T * Clist<T>::Edn_Top()const
{
	if (!head)//不处理任意崩溃
	{
		return NULL;//return NULL;
	}
	else
	{
		return  end->getData();
	}
}

template<typename T>
T *Clist<T>::findval(const T &fin_val)const
{
	if (!head)
	{
		//return NULL;
	}
	else
	{
		Node *temp = head;
		while (temp)
		{
			if (fin_val == *(temp->getData()))
				break;
			temp = temp->getPNext();
		}
		if (!temp)
		{
			return NULL;
		}
		return temp->getData();
	}
}


template<typename T>
void Clist<T>::out_show()const
{
	if (!head)
		return;
	Node *temp = head;
	while (temp)
	{
		std::cout << *(temp->getData()) << " ";
		temp = temp->getPNext();
	}
}


template<typename T>
void  Clist<T>::out_show_reverse()const
{
	if (!end)
		return;
	Node *temp = end;
	while (temp)
	{
		std::cout << *(temp->getData()) << " ";
		temp = temp->getBase();
	}
}


template<typename T>
bool Clist<T>::close()
{
	if (!head)
		return false;
	while (head)
	{
		delete Pop_bak();
	}

	return true;
}

template<typename T>
bool Clist<T>::empty()
{
	return head;
}
template<typename T>
bool Clist<T>::deleteVal(const T &data)
{
	if (!head)
	{
		return false;
	}
	else
	{
		if (data == *(head->getData()) && !head->getPNext())
		{
			delete head->getData();
			delete head;
			head = end = NULL;
			len--;
			return true;
		}
		else
		{
			if (data == *(head->getData()))
			{
				delete head->getData();
				head = head->getPNext();
				delete head->getBase();
				head->SetBase(NULL);
				len--;
				return true;
			}
			else if (data == *(end->getData()))
			{
				delete end->getData();
				end = end->getBase();
				delete end->getPNext();
				end->SetPNext(NULL);
				len--;
				return true;
			}
			else
			{
				Node *temp = head;
				while (temp != end)
				{
					if (data == *(temp->getData()))
					{
						Node *ptmp = temp;
						temp->getPNext()->SetBase(ptmp->getBase());
						temp->getBase()->SetPNext(ptmp->getPNext());
						delete temp->getData();
						delete temp;
						temp = NULL;
						len--;
						return true;
					}
					temp = temp->getPNext();
				}
				return false;
			}
		}

	}
}

#include<iostream>
#include "Clist.hpp"



void main()
{
	
	Clist<int>s;
	for (int i = 0; i < 3; i++)
	{
		s.Push_bak(new int(i+1));
	}
	int val = 0;
	std::cout << "朝找数据:" <<std:: endl;
	std::cin >> val;
	std::cout << s.findval(val);
	std::cout.clear();
	std::cout << "删除数据" << std::endl;
	std::cin >> val;
	if (s.deleteVal(val))
	{
		std::cout << "删除成功\n";
	}
	s.out_show();
	std::cout << std::endl;
	std::cout << "长度:"<<s.getLen() << std::endl;;
	s.Push_bak(1, new int(55));
	std::cout << std::endl;
	s.out_show_reverse();
	s.close();
	s.out_show();




	system("pause");
}