Swap results in non-terminating recursion in Assignment Operator

[mpark4656]

The use of assignment operator results in non-terminating recursion and I can't understand why. It works if I swap by member.

The same copy assignment implementation worked before for other programs.
https://github.com/mpark4656/list_implementation/blob/master/include/List.h

#include <iostream>
#include <algorithm>
#include <initializer_list>

/*
    Create a simple doubly LinkedList class
    Implement const_iterator and iterator interfaces to allow list traversal
*/
class LinkedList
{
private:
    // LinkedList Node
    struct Node
    {
        int data = 0;
        Node* next = nullptr;
        Node* prev = nullptr;

        Node( int data ): next{ nullptr } , prev{ nullptr } , data{ data }
        { }
    };

public:
    // const_iterator interface to allow traversal
    class const_iterator
    {
    protected:
        Node* current;

        // protected constructor that accepts Node*
        // It is protected to prevent user from calling it explicitly
        const_iterator( Node* c ): current{ c }
        { }

        int & retrieve() const
        { return current->data; }

        // LinkedList class needs to be able to access protected constructor
        friend class LinkedList;

    public:
        // Default Constructor
        const_iterator(): current{ nullptr }
        { }

        // Returns element pointed by current
        const int & operator* () const
        { return retrieve(); }

        // Pre-increment operator
        const_iterator & operator++ ()
        {
            if( current != nullptr ) {
                current = current->next;
                return *this;
            }
        }

        // Post-increment operator
        const_iterator operator++ ( int )
        {
            const_iterator old = *this;
            ++( *this );
            return old;
        }

        // Pre-decrement operator
        const_iterator & operator-- ()
        {
            if( current != nullptr ) {
                current = current->prev;
                return *this;
            }
        }

        // Post-decrement operator
        const_iterator operator-- ( int )
        {
            const_iterator old = *this;
            --( *this );
            return old;
        }

        // Compare two const_iterator objects
        bool operator== ( const const_iterator &rhs ) const
        { return current == rhs.current; }

        // Compare two const_iterator objects
        bool operator!= ( const const_iterator &rhs ) const
        { return current != rhs.current; }
    };

    // iterator interface
    class iterator: public const_iterator
    {
    public:
        // Default Constructor
        iterator() {}

        // Allow read/write access to the data
        int & operator* ()
        { return const_iterator::retrieve(); }

        // Pre-increment operator
        iterator & operator++ ()
        {
            if( current != nullptr ) {
                current = current->next;
                return *this;
            }
        }

        // Post-increment operator
        iterator operator++ ( int )
        {
            iterator old = *this;
            ++( *this );
            return old;
        }

    private:
        // Prevent user from calling this constructor explicitly
        iterator( Node* c ): const_iterator{ c }
        { }

        // Allow LinkedList class to access private constructor
        friend class LinkedList;
    };

public:
    // Default Constructor
    LinkedList() {}

    // Copy Constructor
    LinkedList( const LinkedList &rhs )
    {
        Node* temp = rhs.head;

        while( temp != nullptr ) {
            push_back( temp->data );
            temp = temp->next;
        }
    }

    // Move Constructor
    LinkedList( LinkedList &&rhs )
    : theSize{ rhs.theSize } , head{ rhs.head } , tail{ rhs.tail }
    {
        rhs.head = nullptr;
        rhs.tail = nullptr;
    }

    // Brace-Enclosed Initializer
    LinkedList( std::initializer_list<int> iList )
    {
        for( int x : iList ) {
            this->push_back( x );
        }
    }

    // Copy Assignment
    LinkedList & operator= ( const LinkedList &rhs )
    {
        LinkedList copy{ rhs };
        std::swap( *this , copy );
        return *this;
    }

    // Destructor
    ~LinkedList()
    {
        while( head != nullptr ) {
            Node* temp = head;
            head = head->next;
            delete temp;
        }
    }

    void push_front( int x )
    {
        if( head == nullptr ) {
            head = new Node{ x };
            tail = head;
            theSize++;
        }
        else {
            Node* temp = head;
            head = new Node{ x };
            head->next = temp;
            temp->prev = head;
            theSize++;
        }
    }

    void push_back( int x )
    {
        if( tail == nullptr ) {
            tail = new Node{ x };
            head = tail;
            theSize++;
        }
        else {
            Node* temp = tail;
            tail = new Node{ x };
            temp->next = tail;
            tail->prev = temp;
            theSize++;
        }
    }

    void pop_front()
    {
        if( head != nullptr ) {
            Node* temp = head;
            head = temp->next;
            head->prev = nullptr;

            delete temp;
            theSize--;
        }
    }

    void pop_back()
    {
        if( tail != nullptr ) {
            Node* temp = tail;
            tail = temp->prev;
            tail->next = nullptr;

            delete temp;
            theSize--;
        }
    }

    int size()
    { return theSize; }

    const_iterator begin() const
    { return const_iterator{ head }; }

    const_iterator end() const
    { return const_iterator{ nullptr }; }

    iterator begin()
    { return iterator{ head }; }

    iterator end()
    { return iterator{ nullptr }; }

private:
    Node* head = nullptr;
    Node* tail = nullptr;
    int theSize = 0;
};

// Test Driver to test operations of LinkedList
int main()
{
    LinkedList list1 = { 1 , 3 , 5 , 3 , 6 , 7 , 3 };

    LinkedList list2;

    list2 = list1;

    for( int x : list1 ) {
        std::cout << x << std::endl;
    }

    std::cout << std::endl;

    for( int x : list2 ) {
        std::cout << x << std::endl;
    }
}

[Peter87]

std::swap will call the copy assignment operator because you have not defined a move assignment operator.

[mpark4656]

@Peter87
Thank you :)