Overloading Constructor Not Working for Singly Linked List

Question

I have a program where I have tried to make a singly linked list and its copy constructor. The program compiles successfully; however, upon running, it prints half of the output it is supposed to, and then it crashes (sorry for the poor technical vocab) without printing the remaining output.

I have a feeling that something is wrong with my copy constructor in the List class, because the program crashes as it reaches that point.

Here is my code:

# include<iostream>
using namespace std;


class Node
{
    public:
        int value;
        Node* next;
};

class List
{
    public:

        List();
        List(const List &other){
            head = new Node;
            head = NULL;
            Node* temp7;
            temp7 = head;
            Node* temp6 = other.head;
            while (temp6 != NULL)
            {
                temp7 = new Node;
                temp7->value = temp6->value;
                temp7 = temp6;
                temp6 = temp6->next;
            }
        }


        void push_front(int value){
            temporary = new Node;
            temporary->value = value;
            temporary->next = NULL;
            temporary->next = head;
            head = temporary;
        }

        void insert_at(int index, int value){
            Node* temp4 = new Node;
            temp4->value = value;
            temp4->next = NULL;
            if (index == 1)
            {
                temp4->next = head;
                head = temp4;
                return;
            }
            Node* temp5 = head;
            for (int k = 0; k < index - 2; k++)
                temp5 = temp5->next;
            temp4->next = temp5->next;
            temp5->next = temp4;
        }
        void remove_at(int index){
            Node* temp2 = head;
            if (index == 1)
            {
                head = temp2->next;
                delete temp2;
                return;
            }
            for (int j = 0; j < index - 2; j++)
                temp2 = temp2->next;
            Node* temp3 = temp2->next;
            temp2->next = temp3->next;
            delete temp3;
        }

        string printList(void);
    private:
        Node* head; 
        Node* temporary;
};

List::List(){
    head = NULL;
}


string List::printList(void)
{
    Node* temp1 = head;
    int counting = 0;
    while (temp1 != NULL)
    {
        cout << "list[" << counting << "] == " << temp1->value << endl;
        temp1 = temp1->next;
        counting++;
    }
}


int main()
{
    List list1;

    list1.push_front(4);
    list1.push_front(3);
    list1.push_front(2);
    list1.push_front(1);


    cout << "list1" << endl;
    list1.printList();
    cout << endl;

    List list2(list1);

    cout << "list2" << endl;
    list2.printList();
    cout << endl;

    list1.insert_at(1, 6);

    list2.remove_at(2);

    cout << "list1" << endl;
    list1.printList();
    cout << endl;

    cout << "list2" << endl;
    list2.printList();
    cout << endl;


    return 0;
}

I cannot pinpoint the source of error in the program. Can anyone please suggest a solution?

Just for reference, the output should be something like: (The program only outputs the first 5 lines before crashing).

>list1
>
>list[0] == 1
>
>list[1] == 2
>
>list[2] == 3
>
>list[3] == 4
>
>list2
>
>list[0] == 1
>
>list[1] == 2
>
>list[2] == 3
>
>list[3] == 4
>
>list1
>
>list[0] == 1
>
>list[1] == 6
>
>list[2] == 2
>
>list[3] == 3
>
>list[4] == 4
>
>list2
>
>list[0] == 1
>
>list[1] == 2
>
>list[2] == 4

By the way, this is my first question on stack overflow, so if there's anything wrong or something I should be doing, please don't hesitate to correct me.

Thanks a lot for your help everybody :)

*** I fixed the problem. Apparently, I wasn't implementing the copy constructor properly enough. Thanks anyways for all your input and advice :-)

// Include standard files #include

    // Use standard namespace
    using namespace std;

    // Declare node class
    class Node
    {
        // All values are public; value of node, and next node pointer
    public:
        int value;
        Node* next;
    };

    // Declare singly linked list class
    class List
    {
    public:

        // Declare main constructor
        // Declare copy constructor
        List();
        List(const List &copying) : head(NULL)
        {
            // Use a node to move through the source linked list
            // Set the size of the new linked list
            // For every node in old list, copy it to a new node and link it to the new singly linked list
            Node* cur = copying.head;
            int size = copying.size();
            Node* end = NULL;
            for(int q = 0; q < size; q++)
            {
                Node* n = new Node;
                n->value = cur->value;
                if (head == NULL)
                {
                    head = n;
                    end = head;
                }
                else
                {
                    end->next = n;
                    end = n;
                }
                cur = cur->next;
            }
            end->next = NULL;
        }

        // Push front a new node
        // Add its value and set its next pointer to NULL
        void push_front(int value){
            temporary = new Node;
            temporary->value = value;
            temporary->next = NULL;
            temporary->next = head;
            head = temporary;
        }

        // Insert node between x and x+1
        // Get the new node's value
        // Create the new node by moving from the head->next method
        // Add the value and set up the node
        void insert_at(int index, int value){
            Node* temp4 = new Node;
            temp4->value = value;
            temp4->next = NULL;
            if (index == 1)
            {
                Node* temp9 = head->next;
                temp4->next = temp9;
                head->next = temp4;
                return;
            }
            Node* temp5 = head;
            for (int k = 0; k < index - 2; k++)
                temp5 = temp5->next;
            temp4->next = temp5->next;
            temp5->next = temp4;
        }

        // Remove node number [index]
        // Get the head
        // Iterate through the linked list
        // When at the node before the one that has to be deleted, set its value to the node after the next one
        // Delete the node that should be deleted
        void remove_at(int index){
            Node* temp2 = head;
            if (index == 1)
            {
                head = temp2->next;
                delete temp2;
                return;
            }
            for (int j = 0; j < index - 1; j++)
                temp2 = temp2->next;
            Node* temp3 = temp2->next;
            temp2->next = temp3->next;
            delete temp3;
        }

        // Simple function to pass the head of a singly linked list
        // Simple function to get the size of a function
        Node * PassHead(void);
        int size()const;
    private:
        Node* head;
        Node* temporary;
    };

    // Returns head
    Node * List::PassHead()
    {
        return head;
    }

    //  Constructor sets head to NULL
    List::List(){
        head = NULL;
    }

    // Gets the size of the singly linked list.
    // While the node_>next is not NULL, add 1 to counter
    // return counter
    int List::size()const {
        Node* temp1 = head;
        int counting = 0;
        while (temp1 != NULL)
        {
            counting++;
            temp1 = temp1->next;
        }
        return counting;
    }

    // Same function as the size() function, excetp this time, print the node value while iterating through list
    // Nothing returned
    void printList(List object)
    {
        Node* temp1 = object.PassHead();
        int counting = 0;
        while (temp1 != NULL)
        {
            cout << "list[" << counting << "] == " << temp1->value << endl;
            temp1 = temp1->next;
            counting++;
        }
    }

    // Declare main function here
    int main()
    {
        // Object of List
        List list1;

        // Push some values
        list1.push_front(4);
        list1.push_front(3);
        list1.push_front(2);
        list1.push_front(1);

        // Print the first list
        cout << "list1" << endl;
        printList(list1);
        cout << endl;

        // Copy constructor for second list
        List list2(list1);

        // Print second list
        cout << "list2" << endl;
        printList(list2);
        cout << endl;

        // Insert node in first list
        list1.insert_at(1, 6);

        // Remove node in second list
        list2.remove_at(2);

        // Print first list
        cout << "list1" << endl;
        printList(list1);
        cout << endl;

        // Print second list
        cout << "list2" << endl;
        printList(list2);
        cout << endl;


        // Program ran successfully
        return 1;
    }

Answer 1

I just can't answer normal due not enough points on this page. But I found something.

 List(const List &other){
            head = new Node;
            head = NULL;
            Node* temp7;
            temp7 = head;
            Node* temp6 = other.head;
            while (temp6 != NULL)
            {
                temp7 = new Node;
                temp7->value = temp6->value;
                temp7 = temp6;
                temp6 = temp6->next;
        }

Where is the closing bracket? The next function will be created in the function called List(const List &other) { .... Add a bracket and try again. Hope that helps ;)