Linked List Copy Constructor | Undefined Behavior

Question

I've been building on a template Linked List and recently implemented a user-defined copy constructor to handle deep copies of my Linked List. My current solution compiles just fine but when I execute, nothing is displayed.

#include <iostream>

template<typename T>
class LinkedList
{
private:
    struct Node
    {
        T data;
        Node* next;
    };

    Node* head;
    Node* tail;
    int size;

public:
    LinkedList();
    LinkedList(const LinkedList<T> &list);
    ~LinkedList();
    LinkedList<T>& operator=(const LinkedList<T> list);
    int getSize() const;
    void display() const;
    void push(const T &data);
    void insert(const int pos, const T &data);
    void remove(const int pos);

};

template<typename T>
LinkedList<T>::LinkedList() : head{ nullptr }, tail{ nullptr }, size{ 0 }
{
}

// TODO: User-defined copy constructor
template<typename T>
LinkedList<T>::LinkedList(const LinkedList<T> &list)
    : head{ nullptr }, tail{ nullptr }, size{list.size}
{
    std::cout << "In the copy constructor\n";
    if (list.head == nullptr)
    {
        return;
    }
    else
    {
        Node* curNode = new Node{list.head->data, nullptr};
        head = curNode; // sets the head member variable to first node in Linked List

        Node* curListNode = list.head;      

        while (curListNode->next != nullptr)
        {
            curNode->next = new Node{curListNode->next->data, nullptr};

            curListNode = curListNode->next;
            curNode = curNode->next;
        }

        curNode->next = new Node{curListNode->next->data, nullptr};
        tail = curNode->next;
    }

}

template<typename T>
LinkedList<T>::~LinkedList()
{
    Node* prevNode = head;
    Node* curNode = head;

    while(curNode != nullptr)
    {
        prevNode = curNode;
        curNode = curNode->next;

        delete prevNode;
    }

    head = nullptr;
    tail = nullptr;
}

template<typename T>
LinkedList<T>& LinkedList<T>::operator=(const LinkedList<T> list)
{
    // make a copy of each node - much like the copy constructor
    std::cout << "In the overloaded assignment\n";
}

template<typename T>
int LinkedList<T>::getSize() const
{
    return size;
}

template<typename T>
void LinkedList<T>::display() const
{
    Node* curNode = head;

    while (curNode != nullptr)
    {
        std::cout << curNode->data << '\n';
        curNode = curNode->next;
    }

    std::cout << '\n';
}

template<typename T>
void LinkedList<T>::push(const T &data)
{
    Node* newNode = new Node{data, nullptr};

    if (size == 0)
    {
        head = newNode;
        tail = newNode;
    }
    else 
    {
        tail->next = newNode;
        tail = newNode;
    }

    ++size;
}

template<typename T>
void LinkedList<T>::insert(const int pos, const T &data)
{
    if (pos < 0 || pos > size)
    {
        throw "Index is out of range!";   
    }
    else if (pos == size)
    {
        push(data);   
    }
    else
    {
        Node* newNode = new Node{data, nullptr};
        Node* prevNode = head;
        Node* curNode = head;

        int i = 0;
        while (i != pos)
        {
            prevNode = curNode;
            curNode = curNode->next;
            ++i;
        }

        prevNode->next = newNode;
        newNode->next = curNode;

        ++size;
    }
}

template<typename T>
void LinkedList<T>::remove(const int pos)
{
    if (pos < 0 || pos > size)
    {
        throw "Index is out of range!";   
    }
    else if (size == 0)
    {
        throw "List is empty!";   
    }
    else
    {
        Node* prevNode = head;
        Node* curNode = head;

        int i = 1;
        while (i != pos)
        {
            prevNode = curNode;
            curNode = curNode->next;
            ++i;
        }

        prevNode->next = curNode->next;
        delete curNode;

        if (pos == size)
        {
            tail = prevNode;   
        }

        --size;
    }
}

int main()
{
    LinkedList<int> list;

    list.push(1);
    list.push(3);
    list.push(6);

    list.display();

    LinkedList<int> copyList{list};

    copyList.display();

    return 0;
}

The first LinkedList<int> list doesn't even display when I add the the copyList statement to main(). However, when I comment out the two copyList statements, list displays as normal.

I added print statements to see if either the copy constructor or the operator= functions were being called and neither of those are printed to the console when the copyList statements are added to my program (the code compiles just fine).

I could use any help to help diagnose what's causing this behavior.

Answer 1

A simple copy constructor like this one should suffice:

template<typename T>
LinkedList<T>::LinkedList(const LinkedList<T> &list)
    : head{ nullptr }, tail{ nullptr }, size{0}
{
    std::cout << "In the copy constructor\n";
   Node* curNode = list.head;

    while (curNode != nullptr)
    {
      this->push(curNode->data);
        curNode = curNode->next;
    }

}

Note that this is just your display method rewritten to insert elements in the current list.