1. using namespace std;
template<typename T>
List<T>::List()
: m_head(new Element), m_end(m_head)
{
}
template<typename T>
List<T>::List(const List &list)
: m_head(new Element), m_end(m_head)
{
for (Element *p = list.m_head; p != list.m_end; p = p->next)
PutAtEnd(p->data);
}
template<typename T>
List<T>::~List()
{
BecomeEmpty();
delete m_end;
}
template<typename T>
List<T> & List<T>::operator=(List<T> rightSide)
{
swap(m_head, rightSide.m_head);
swap(m_end, rightSide.m_end);
return *this;
}
template<typename T>
bool List<T>::isEmpty() const
{
return (m_head == m_end);
}
template<typename T>
void List<T>::InsertAtBeginning(T data)
{
Element *neww = new Element;
neww->data = data;
neww->next = m_head;
m_head = neww;
}
template<typename T>
void List<T>::PutAtEnd(T data)
{
Element *newwEnd = new Element;
m_end->data = data;
m_end->next = newwEnd;
m_end = newwEnd;
}
template<typename T>
void List<T>::remove(typename List<T>::Iterator it)
{
if (it != this->begin())
throw "Unsupported operation";

2. Element * p = this->m_head;
this->m_head = this->m_head->next;
delete p;
}
template<typename T>
void List<T>::BecomeEmpty()
{
while (!isEmpty())
{
Element *p = m_head;
m_head = m_head->next;
delete p;
}
}
template<typename T>
typename List<T>::Iterator List<T>::begin()
{
Iterator iter;
iter.m_Element = m_head;
return iter;
}
template<typename T>
typename List<T>::Iterator List<T>::end()
{
Iterator iter;
iter.m_Element = m_end;
return iter;
}
template<typename T>
typename List<T>::ConstantIterator List<T>::begin() const
{
ConstantIterator iter;
iter.m_Element = m_head;
return iter;
}
template<typename T>
typename List<T>::ConstantIterator List<T>::end() const
{
ConstantIterator iter;
iter.m_Element = m_end;
return iter;
}
// Class Iterator
template<typename T>
typename List<T>::Iterator & List<T>::Iterator::operator++()
{
m_Element = m_Element->next;
return *this;
}
template<typename T>
const typename List<T>::Iterator List<T>::Iterator::operator++(int)
{

3. Iterator iter(*this);
++(*this);
return iter;
}
// Class ConstantIterator
template<typename T>
typename List<T>::ConstantIterator & List<T>::ConstantIterator::operator++()
{
m_Element = m_Element->next;
return *this;
}
template<typename T>
const typename List<T>::ConstantIterator
List<T>::ConstantIterator::operator++(int)
{
ConstantIterator iter(*this);
++(*this);
return iter;
}
template<typename T>
std::ostream &operator<<(std::ostream &steam, const List<T> &list)
{
for (typename List<T>::ConstantIterator iter = list.begin(); iter !=
list.end(); ++iter)
steam << *iter << " ";
return steam;
}