Trouble with a list class

[InfiniteLoop]

I've been working on a List class for a couple weeks and recently I've been having lots trouble with it. From what I can gather, there's something wrong with the List::operator =, and there's a little bug somewhere causing an if else statement in push_back to loop. The lab guy I asked believes it's somewhere in List or List_iterator. Anyone have any idea why this is happening?

  #ifndef LIST_H
#define LIST_H

// List.h - a doubly-linked list

#include <algorithm>
#include <iostream>

using namespace std;

// forward declaration of classes defined in this header
template <class T> class Link;
template <class T> class List_iterator;//prototype class declaration

template <class T> 
class List
{
public:
   typedef List_iterator<T> iterator;

   List();
   List(const List<T> & l);
   ~List();

   bool empty() const {return my_size==0;}//check if empty
   unsigned int size() const; 
   T & back() const {return last_link->value;}
   T & front() const {return first_link->value;}
   void push_front(const T & x);//put value in front
   void push_back(const T & x);//put value in back
   void pop_front();//delete value from front
   void pop_back();//delete value from back
   iterator begin() const {return iterator(first_link);}
   iterator end() const {return iterator();}
   void insert(iterator pos, const T & x);//insert x before iterator position
   void erase(iterator & pos) {erase(pos);}//position must be valid after erase() returns
   List<T> & operator=(const List<T> & l);

protected:
   Link<T> * first_link;
   Link<T> * last_link;
   unsigned int my_size;
};

template <class T>
List<T>::List()
{
        first_link = 0;
        last_link = 0;
        my_size = 0;
}

template <class T>
List<T>::List(const List & l)
{
    first_link = 0;
    last_link = 0;
    my_size = 0;
    for(Link<T>*current=l.first_link;current!= 0;current=current->next_link)
        push_back(current -> value);
}

template <class T>
List<T>::~List()
{
    while(last_link!=NULL)//while list is not empty
    {
        delete last_link;
    }
}

template <class T>
unsigned int List<T>::size() const
{
    /*int counter=0;
    for(Link<T>*ptr=first_link;ptr!=0; ptr=ptr->next_link)
    {
        counter++;
        cout<<"hi";
    }
    return counter;*/
    return my_size;
}

template <class T>
void List<T>::push_front(const T&x)//add new value to front
{
    Link<T>*new_link=new Link<T>(x);
    if(empty())//if empty
    {
        first_link=last_link=new_link;
    }
    else//if not empty
    {
        first_link->prev_link=new_link;//
        new_link->next_link=first_link;
        first_link=new_link;//the new value becomes the first
    }
    my_size++;
}

template <class T>
void List<T>::push_back(const T& x)//add new value to back
{
    Link<T>*new_link=new Link<T>(x);
    //last_link->prev_link=new_link;
    //new_link->next_link=last_link;
    if(first_link==0)//if first is 0/empty?
    {
        first_link=last_link=new_link;
    }
    else
    {
        new_link->prev_link=last_link;
        last_link->next_link=new_link;
        last_link=new_link;//new becomes the last
        cout<<"LOOP";//loop trap. THIS IS WHERE LOOPING HAPPENS. Displays LOOP over and over in console.
    }
    my_size++;
}

template <class T>
void List<T>::pop_front()//delete from front
{
    Link<T>*temp=first_link;
    first_link=first_link->next_link;
    if(first_link!=0)//if first is not 0
    {
        first_link->prev_link=0;
    }
    else
    {
        last_link=0;
    }
    delete temp;
    my_size--;
}

template <class T>
void List<T>::pop_back()
{
    Link<T>*temp=last_link;
    last_link=last_link->prev_link;
    if(last_link!=0)
    {
        last_link->prev_link=0;
    }
    else
    {
        last_link=0;
    }
    delete temp;
    my_size--;
}

template <class T> //insert x before pos
void List<T>::insert(iterator pos, const T & x)
{
    Link<T>*new_link=new Link<T>(x);
    if(new_link==0)
    {
        cout<<"hi ";
        exit(1);
    }
    my_size++;
    Link<T>*next=pos.current_link;
    Link<T>*prev=next->prev_link;
    
    new_link->next_link=next;
    next->prev_link=new_link;
    new_link->prev_link=prev;
    
    if(prev==0)
    {
        first_link=new_link;
    }
    else
    {
        prev->next_link=new_link;
    }
}

template <class T>
List<T>&List<T>::operator=(const List<T> & l)
{
    List_iterator<T> the_list;
    return l=the_list;
}


//Class Link
template <class T> 
class Link 
{
private:
   Link(const T & x): value(x), next_link(0), prev_link(0) {}
                
   T value;     
   Link<T> * next_link;
   Link<T> * prev_link;

   friend class List<T>;
   friend class List_iterator<T>;
};

template <class T> class List_iterator
{
public:
   typedef List_iterator<T> iterator;

   List_iterator(Link<T> * source_link): current_link(source_link) { }
   List_iterator(): current_link(0) { }
   List_iterator(List_iterator<T>*source_iterator):current_link(source_iterator.current_link){ }

   T & operator*();  // dereferencing operator
   iterator & operator=(const iterator & rhs);
   bool operator==(const iterator & rhs) const;
   bool operator!=(const iterator & rhs) const;
   iterator & operator++();  // pre-increment, ex. ++it
   iterator operator++(int); // post-increment, ex. it++
   iterator & operator--();  // pre-decrement
   iterator operator--(int); // post-decrement

protected:
   Link<T> * current_link;
   List<T> * the_list;

   friend class List<T>;
};

template <class T>
T & List_iterator<T>::operator*()
{
        return current_link -> value;
}

template <class T>
List_iterator<T> & List_iterator<T>::operator=(const iterator & rhs)
{
    the_list=rhs.the_list;
    current_link=rhs.current_link;
}

template<class T>
bool List_iterator<T>::operator==(const iterator & rhs) const
{
    return (this->current_link==rhs.current_link); 
}

template <class T>
bool List_iterator<T>::operator!=(const iterator & rhs) const
{
    return !( *this == rhs );
}

template <class T>
List_iterator<T> & List_iterator<T>::operator++() // pre-increment
{
        current_link = current_link -> next_link;
        return *this;
}

template <class T>
List_iterator<T> List_iterator<T>::operator++(int)
{
    List_iterator<T> clone(current_link);
    current_link=current_link->next_link;
    return clone;
}

template <class T>
List_iterator<T>&List_iterator<T>::operator--()
{
    current_link=current_link->prev_link;
    return *this;
}

template <class T>
List_iterator<T> List_iterator<T>::operator--(int)
{
    List_iterator<T> clone(the_list, current_link);
    current_link=current_link->prev_link;
    return clone;
}

#endif 

And for the sake of reference, here's the .cpp file I'm using to test.

#include <iostream>
#include <cassert>
#include "List.h"

using namespace std;

int main()
{
   List<int> l;

   assert(l.size() == 0);
   assert(l.empty());

   l.push_front(44);         // list = 44
   assert(!l.empty());
   assert(l.front() == 44);
   assert(l.back() == 44);

   l.push_front(33);         // list = 33, 44
   assert(l.size() == 2);
   assert(l.front() == 33);
   assert(l.back() == 44);

   l.push_front(22);         // list = 22, 33, 44
   List<int>::iterator it = l.begin();
   l.insert(it, 11);         // list = 11, 22, 33, 44
   it = l.begin();
   assert(l.front() == 11);
   assert(*it == 11);
   assert(*++it == 22);
   assert(*++it == 33);
   assert(*++it == 44);

   it = l.begin();
   ++it;
   ++it;
   ++it;
   l.insert(it, 38);         // list = 11, 22, 33, 38, 44
   List<int>::iterator it2 = l.begin();
   assert(*it2 == 11);
   assert(*++it2 == 22);
   assert(*++it2 == 33);
   assert(*++it2 == 38);
   assert(*++it2 == 44);

   l.pop_front();            // list = 22, 33, 38, 44
   it2 = l.begin();
   assert(*it2 == 22); 
   assert(*++it2 == 33);     
   assert(*++it2 == 38);
   assert(*++it2 == 44);
   
   l.pop_back();             //list = 22, 33, 38
   List<int> copy = l;       //copy = 22, 33, 38
   assert(copy.size() == 3);
   List<int>::iterator it3 = copy.begin();
   assert(*it3 == 22);
   assert(*++it3 == 33);
        
   copy.erase(it3);         //copy = 22, 38
   assert(copy.size() == 2); 
   it3 = copy.begin(); 
   assert(*it3 == 22);
   assert(*++it3 == 38);
   
   cout << "SUCCESS\n";
}  

[InfiniteLoop]

Anybody? This is seriously stumping me.