Перегрузочный конструктор, не работающий для одиночно связанного списка

Question

У меня есть программа, в которой я попытался создать отдельно связанный список и его конструктор копий. Программа успешно компилируется; однако при запуске он печатает половину выходного файла, который он должен использовать, а затем он падает (извините за плохой технический vocab), не распечатывая оставшийся результат.

У меня такое ощущение, что что-то не так с моим конструктором копирования в классе List, потому что программа выходит из строя, когда она достигает этой точки.

Вот мой код:

# 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; 
} 

Я не могу точно определить источник ошибки в программе. Может кто-нибудь предложить решение?

Для справки, выход должен быть чем-то вроде: (Программа выводит только первые 5 строк перед сбоем).

>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 

Кстати, это мой первый вопрос на переполнение стека, так что если есть что-то не так или что-то я должен делать, пожалуйста, не стесняйтесь, поправьте меня.

Большое спасибо за вашу помощь всем :)

*** Я исправил эту проблему. По-видимому, я недостаточно правильно выполнял конструктор копирования. Спасибо в любом случае для всех ваших входных и советы :-)

// Включить стандартные файлы #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

Я просто не могу ответить на нормальный не хватает из-за очков на этой странице. Но я кое-что нашел.

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; 
     } 

Где находится закрывающая скобка? Следующая функция будет создана в функции List (const List & other) {.... Добавьте скобку и повторите попытку. Надеюсь, что помогает;)