HA16

#include <iostream>

class List {
private:
    class Node {
    public:
        Node(int val) : value(val), next(nullptr), prev(nullptr) {}

        int value;
        Node* next;
        Node* prev;
    };

    Node* start;
    Node* finish;
    int size;

public:
    // Тут инициализируем
    List() : start(nullptr), finish(nullptr), size(0) {}

    // Тут конструктор копирования - его применим внизу
    List(const List& other) : start(nullptr), finish(nullptr), size(0) {
        Node* current = other.start;
        while (current) {
            push_back(current->value);
            current = current->next;
        }
    }

    // Деструктор
    ~List() {
        while (size > 0) {
            pop_front();
        }
    }

    void push_back(int new_value) {
        Node* new_node = new Node(new_value);
        if (size > 0) {
            finish->next = new_node;
            new_node->prev = finish;
        } else {
            start = new_node;
        }
        finish = new_node;
        ++size;
    }

    void push_front(int new_value) {
        Node* new_node = new Node(new_value);
        new_node->next = start;
        if (start != nullptr) {
            start->prev = new_node;
        }
        start = new_node;
        if (size == 0) {
            finish = new_node;
        }
        ++size;
    }

    void pop_front() {
        if (size == 0) {
            return;
        }
        Node* old_start = start;
        start = start->next;
        if (start != nullptr) {
            start->prev = nullptr;
        } else {
            finish = nullptr;
        }
        delete old_start;
        --size;
    }

    void pop_back() {
        if (size == 0) {
            return;
        }
        Node* old_finish = finish;
        finish = finish->prev;
        if (finish != nullptr) {
            finish->next = nullptr;
        } else {
            start = nullptr;
        }
        delete old_finish;
        --size;
    }

    Node* getStart() const { return start; }
    int getSize() const { return size; }

    void print() const {
        Node* current = start;
        while (current != nullptr) {
            std::cout << current->value << " ";
            current = current->next;
        }
        std::cout << std::endl;
    }
};

int main() {
    // Вводим количество элементов
    int num_elements;
    std::cout << "Количество элементов: ";
    std::cin >> num_elements;

    // Вводим элементы
    List list;
    std::cout << "Элементы: ";
    for (int i = 0; i < num_elements; ++i) {
        int value;
        std::cin >> value;
        list.push_back(value);
    }

    // Копируем список конструктором копирования
    List copied_list = list;

    // Вводим и выполняем команды добавления и удаления элементов
    int n, m, k, l;
    std::cout << "push front: ";
    std::cin >> n;
    list.push_front(n);

    std::cout << "push back: ";
    std::cin >> m;
    list.push_back(m);

    std::cout << "pop front: ";
    std::cin >> k;
    list.pop_front();

    std::cout << "pop back: ";
    std::cin >> l;
    list.pop_back();

    // Повторное копирование списка
    List another_copied_list = list;

    // Отображение всех трех списков и их адресов в памяти
    std::cout << "Оригинальный список: ";
    copied_list.print();
    std::cout << "Оригинальное место в памяти: " << &copied_list << std::endl;

    std::cout << "Список: ";
    list.print();
    std::cout << "Место в памяти: " << &list << std::endl;

    std::cout << "Еще один список: ";
    another_copied_list.print();
    std::cout << "Еще одно место в памяти: " << &another_copied_list << std::endl;

    return 0;
}