Односвязные списки

@laant · Регистрация: 16.02.2022

Author24 — интернет-сервис помощи студентам

Криво косо написано, вроде как даже работает, но абсолютно нет понимания перегрузки оператора +.
Почему когда обнуляю newList.Size, тогда работает, если убираю данную строку тогда ничего не выводит в списке3.

C++

#include <iostream>
#include <string>
//#include <ctype.h>
//#include <conio.h>
#include <windows.h>
#include <time.h>
 
using namespace std;
 
template <typename T>
class List
{
private:
 
    
    class Node
    {
    public:
        Node* pNext;
        T data;
        Node(T data = T(), Node* pNext = nullptr)
        {
            this->data = data;
            this->pNext = pNext;
        }
    };
    int Size;
    Node* head;
    //Node* prev;
public:
    List();          // конструктор по умолчанию  
 
    // list(T* data);   // конструктор с параметром   
 
    ~List();         //деструктор 
 
    List (const List<T>&); // конструктор копирования
 
    void pop_front(); //удаление первого элемента в списке
 
    void push_back(T data); //добавление элемента в конец списка
 
    void clear();  // очистить список
 
    int GetSize() { return Size; } // получить количество елементов в списке
 
    T& operator[](const int index); // перегруженный оператор [] 
 
    void push_front(T data); //добавление элемента в начало списка
 
    void insert(T data, int index); //добавление элемента в список по указанному индексу
 
    void removeAt(int index); //удаление элемента в списке по указанному индексу
 
    void pop_back(); //удаление последнего элемента в списке
 
    void print(); // показ всего списка
 
    List<T>& operator = (const List<T>&); // оператор присваивания (клонирования)
    
    List<T>& operator + (const List<T>&); // оператор сложения списков
};
 
template<typename T>
List<T>::~List()
{
    cout << " деструктор " << endl;
    clear();
}
 
template<typename T>
List<T>::List()
{
    cout << " конструктор по умолчанию " << endl;
    Size = 0;
    head = nullptr;
}
 
template<typename T>
List<T>::List(const List& list)
{
    head = nullptr;
    Size = 0;
    //Голова списка, из которого копируем
    Node* temp = list.head;
    //Пока не конец списка
    
    while (temp != 0)
    {
        //Перебираем данные
        push_back(temp->data);
        temp = temp->pNext;
    }
 
}
 
 
template<typename T>
void List<T>::pop_front()
{
    cout << " метод удаления первого элемента " << endl;
    if (head != nullptr)
    {
        Node* temp = head;
 
        head = head->pNext;
 
        delete temp;
 
        Size--;
    }   
}
 
template<typename T>
void List<T>::push_back(T data)
{
    cout << " метод добавления элемента в конец списка " << endl;
    if (head == nullptr)
    {
        head = new Node(data);
    }
    else
    {
        Node* current = this->head;
 
        while (current->pNext != nullptr)
        {
            current = current->pNext;
        }
        current->pNext = new Node(data);
 
    }
 
    Size++;
}
 
template<typename T>
void List<T>::clear()
{
    cout << " метод очистки всего списка " << endl;
    while (Size)
    {
        pop_front();
    }
}
 
template<typename T>
T& List<T>::operator[](const int index)
{
    int counter = 0;
 
    Node* current = this->head;
 
    while (current != nullptr)
    {
        if (counter == index)
        {
            return current->data;
        }
        current = current->pNext;
        counter++;
    }
}
 
template<typename T>
void List<T>::push_front(T data)
{
    cout << " метод встаки элемента в начало " << endl;
    head = new Node(data, head);
    Size++;
}
 
template<typename T>
void List<T>::insert(T data, int index)
{
    cout << " метод вставки определенного элемента по индексу " << endl;
    if (index == 0)
    {
        push_front(data);
    }
    else
    {
        Node* previous = this->head;
 
        for (int i = 0; i < index - 1; i++)
        {
            previous = previous->pNext;
        }
 
        Node* newNode = new Node(data, previous->pNext);
 
        previous->pNext = newNode;
 
        Size++;
    }
}
 
template<typename T>
void List<T>::removeAt(int index)
{
    cout << " метод удаления элемента по индексу " << endl;
    if (index == 0)
    {
        pop_front();
    }
    else
    {
        Node* previous = this->head;
        for (int i = 0; i < index - 1; i++)
        {
            previous = previous->pNext;
        }
 
        Node* toDelete = previous->pNext;
 
        previous->pNext = toDelete->pNext;
 
        delete toDelete;
 
        Size--;
    }
 
}
 
template<typename T>
void List<T>::pop_back()
{
    cout << "метод удаления последнего элемента " << endl;
    removeAt(Size - 1);
}
 
template<typename T>
void List<T>::print()
{   
    cout << " Печать списка " << endl;
    Node* cur;
    for (cur = head; cur!=NULL; cur=cur->pNext)
    {       
        cout <<cur->data << endl;       
    }
    cout << endl;
}
 
template<typename T>
List<T>& List<T>::operator =(const List<T>& list)
{
    cout << " перегруженный оператор присваивания (=) " << endl;
    if (this == &list)
        return *this;
    this->Size = list.Size;     
    Node* last = nullptr;
    for (Node* n = list.head; n != nullptr; n = n->pNext)
    {
        Node* item = new Node(n->data);
        if (!head)
        {
            head = item;
        }
        else
        {
            last->pNext = item;
        }
        last = item;
        
    }   
    return *this;
 
 
    ////Проверка присваивания элемента "самому себе"
    //if (this == &list)
    //  return *this;
    ////удаление старого списка
    //this->~List(); // DelAll();
    //Node* temp = list.head;
    ////Копируем элементы
    //while (temp != 0)
    //{
    //  push_back(temp->data);
    //  temp = temp->pNext;
    //}
    //return *this;
}
 
template<typename T>
List<T>& List<T> :: operator +(const List<T>& list)
{   
    List<T> newList(*this); //Создаю новый список  
    Node* temp = list.head; //Временная переменная, хранящая в себе элемент списка. Начинаем с головы.
    int i = 0;
    //int count=-5;     
    while (i++ < list.Size)
    {
        newList.push_back(temp->data);
        temp = temp->pNext;
        //count++;  
        //i++;
    }
    cout << " вооооооооот1 " << endl;
    newList.print();
 
     //newList.Size = 0;
    
    // перед возвращением newList вызывается деструктор и подчищает временно созданный объект
    return newList; //Возвращаю указатель новый созданный список.
 
}
 
 
 
int main()
{
    setlocale(LC_ALL, "");
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);
 
    List<int> lst;
    lst.push_front(5);
    lst.push_front(7);
    lst.push_front(101);
    lst.push_back(196);
    lst.push_back(777);
 
 
    lst.print();
    cout << "insert " << endl ;
    lst.insert(555, 2);
    lst.print();
    cout << "pop_back " << endl;
    lst.pop_back();
    lst.print();
    cout << "removeAt " << endl ;
    lst.removeAt(3);
    lst.print();
    cout << "pop_front " << endl ;
    lst.pop_front();
    lst.print();
 
    cout << " Создаем новый список, копируя данные из старого" << endl;
    List<int> list1;
    list1 = lst;
    list1.print();
    cout << endl;
    cout << " Другой список" << endl;
    List<int> list2;
    list2.push_front(13);
    list2.push_front(4);
    list2.push_front(27);
    list2.push_back(87);
    list2.push_back(267); 
    list2.print();
    cout << endl;
    cout << " Сумма первого списка и другого" << endl;
    List<int> list3 = list1 + list2;    
    list3.print();
 
    
 
 
 
 
 
 
    system("Pause");
    //_getch();
    return 0;
}

@abit · 22.08.2022, 15:33

C++

template<typename T>
List<T>& List<T> :: operator +(const List<T>& list)
{   
    List<T> newList(*this); //Создаю новый список  
    Node* temp = list.head; //Временная переменная, хранящая в себе элемент списка. Начинаем с головы.
    int i = 0;
    //int count=-5;     
    while (i++ < list.Size)
    {
        newList.push_back(temp->data);
        temp = temp->pNext;
        //count++;  
        //i++;
    }
    cout << " вооооооооот1 " << endl;
    newList.print();
 
     //newList.Size = 0;
    
    // перед возвращением newList вызывается деструктор и подчищает временно созданный объект
    return newList; //Возвращаю указатель новый созданный список.
 
}

Не смущает что List<T> newList(*this); локальна и по выходу из функции оператора вызывается деструктор для newList и чего там остаётся от того, что возвращается через return никто не знает, о чём, кстати в комментарии и написано)))

подозреваю действовать надо как-то так

C++

template<typename T>
List<T>& List<T> :: operator +(const List<T>& list)
{   
 
    Node* temp = list.head; 
    int i = 0;
 
    while (i++ < list.Size)
    {
        this->push_back(temp->data);
        temp = temp->pNext;
    }
   
    this->print();
 
    return *this; 
 
}

	22.08.2022, 15:33