Двусвязный список. Перегрузка оператора.

Дмитрий Жук

Доброго времени суток!
Никак не получается перегрузить оператор + (сцепление двух списков). Как мне кажется ошибка в копирующем конструкторе или деструкторе, т.к. если удалить код внутри деструктора, то всё работает правильно.
Пытался пошагово отлаживать программу и увидел, что после функции перегрузки, программа заходит в копирующий конструктор, а потом срабатывает деструктор, после которого все данные из Node удаляются, и в результате остаётся только мусор.

#include <iostream>
using namespace std;

typedef unsigned int uint;

struct Node
{
    int data;
    Node* next;
    Node* prev;

    Node() : data(0), next(NULL), prev(NULL) {}
    Node(int value) : data(value), next(NULL), prev(NULL) {}
};

class DoublyLinkedList
{
private:
    uint size;
    Node *head;
    Node *tail;

public:
    DoublyLinkedList();
    ~DoublyLinkedList();
    DoublyLinkedList(const DoublyLinkedList &);

    void insertFront(int);
    void insertBack(int);
    void deleteFront();
    void deleteBack();
    bool isEmpty();
    void show();
    Node *findByIndex(int);

    DoublyLinkedList operator + (const DoublyLinkedList &);//слияние двух списков
};

DoublyLinkedList::DoublyLinkedList() : size(0), head(NULL), tail(NULL) {}

DoublyLinkedList::~DoublyLinkedList()
{
    while (!isEmpty()){
        deleteFront();
        cout << "Удалил узел!" << endl;
    }
}

DoublyLinkedList::DoublyLinkedList(const DoublyLinkedList &otherList){

    head = otherList.head;
    size = otherList.size;
    tail = otherList.tail;

    //show();
}

bool DoublyLinkedList::isEmpty(){
    return bool(size == 0);
}

void DoublyLinkedList::insertFront(int value){
    Node* tmpNode = new Node(value);
    if (head == NULL)
        head = tail = tmpNode;
    else{
        head->prev = tmpNode;
        tmpNode->next = head;
        head = tmpNode;
    }
    size++;
}

void DoublyLinkedList::insertBack(int value){
    Node* tmpNode = new Node(value);
    if (head == NULL)
        head = tail = tmpNode;
    else{
        tail->next = tmpNode;
        tmpNode->prev = tail;
        tail = tmpNode;
    }
    size++;
}

void DoublyLinkedList::deleteFront(){
    if (!isEmpty()){
        Node* tmpNode = head;
        head = head->next;
        //head->prev = NULL;
        delete tmpNode;
        size--;
    }
}

void DoublyLinkedList::deleteBack(){
    if (!isEmpty()){
        Node* tmpNode = tail;
        tail = tail->prev;
        tail->next = NULL;
        delete tmpNode;
        size--;
    }
}

void DoublyLinkedList::show(){
    if (!size){
        cout << "Список пуст\n";
    }
    else{
        cout << "Элементы списка:\n";
        Node *tmpNode = head;
        while (tmpNode != NULL){
            cout << tmpNode->data << " -> ";
            tmpNode = tmpNode->next;
        }
        cout << "NULL\n";
    }
}

Node *DoublyLinkedList::findByIndex(int index){
    if ((index < 1) || (index > size)){
        return NULL;
    }
    else{
        Node *tmpNode = head;
        for (int i = 1; i < index; i++){
            tmpNode = tmpNode->next;
        }
        return tmpNode;
    }
}

DoublyLinkedList DoublyLinkedList::operator + (const DoublyLinkedList &otherList){
    DoublyLinkedList *result = new DoublyLinkedList();
    result->size = size + otherList.size;
    result->head = head;
    result->tail = tail;
    tail->next = otherList.head;
    otherList.head->prev = tail;

    //show();
    return *result;
}

int main()
{
    setlocale(LC_ALL, "rus");

    DoublyLinkedList l1;
    l1.insertBack(1);
    l1.insertBack(3);
    l1.insertBack(5);
    l1.show();
    DoublyLinkedList l2;
    l2.insertBack(8);
    l2.insertBack(38);
    l2.insertBack(58);
    l2.show();
    DoublyLinkedList l3;
    l3 = l1 + l2;
    l3.show();

    //cin.get();
    return 0;
}
Дмитрий Жук 8 месяцев назадСпасибо 0
1 чел.