mumbo jumbo

#include <iostream>
#include <cmath>

class Node {
public:
    int data{};
    Node* next;
    Node* previous;

    Node() {
        next = nullptr;
        previous = nullptr;
    }
    Node(int d, Node n, Node p) {
        data = d;
        next = &n;
        previous = &p;
    }
};

class List {
public:
    List() {
        head = nullptr;
        tail = nullptr;
        size_ = 0;
    }
    List(int* values, size_t size) {
        size_ = size;
        if (size == 0) {
            return;
        }
        head = new Node();
        if (std::abs(values[0]) > 2000000000) {
            throw std::runtime_error("Wrong Value!");
        }
        head->data = values[0];
        head->next = new Node();
        head->next->previous = head;
        Node* curr = head;
        for (size_t i = 1; i < size; i++) {
            if (std::abs(values[i]) > 2000000000) {
                throw std::runtime_error("Wrong Value!");
            }
            curr = curr->next;
            curr->data = values[i];
            curr->next = new Node();
            curr->next->previous = curr;
        }
        tail = curr;
        tail->next = head;
        head->previous = tail;
    }
    ~List() {
        if (head == nullptr) {
            return;
        }
        Node* prev = nullptr;
        Node* curr = head;
        while (curr != tail) {
            prev = curr;
            curr = curr->next;
            prev->next = nullptr;
            prev->previous = nullptr;
            delete prev;
        }
        curr->next = nullptr;
        curr->previous = nullptr;
        delete curr;
    }

    void pushBack(int value) {
        if (std::abs(value) > 2000000000) {
            throw std::runtime_error("Wrong Value!");
        }
        size_++;
        if (head == nullptr) {
            head = new Node();
            tail = head;
            tail = head;
            head->data = value;
            head->next = tail;
            head->previous = tail;
            return;
        }
        Node* curr = new Node();
        curr->data = value;
        tail->next = curr;
        curr->previous = tail;
        tail = curr;
        tail->next = head;
        head->previous = tail;
    }
    void pushFront(int value) {
        if (std::abs(value) > 2000000000) {
            throw std::runtime_error("Wrong Value!");
        }
        size_++;
        if (head == nullptr) {
            head = new Node();
            tail = head;
            tail = head;
            head->data = value;
            head->next = tail;
            head->previous = tail;
            return;
        }
        Node* curr = new Node();
        curr->data = value;
        head->previous = curr;
        curr->next = head;
        head = curr;
        head->previous = tail;
        tail->next = head;
    }
    int pop() {
        if (head == nullptr) {
            throw std::runtime_error("Can not pop such element!");
        }
        size_--;
        if (head == tail) {
            int tmp = head->data;
            head = nullptr;
            tail = nullptr;
            return tmp;
        }
        Node* curr = head;
        head = head->next;
        head->previous = tail;
        tail->next = head;
        curr->previous = nullptr;
        curr->next = nullptr;
        int tmp = curr->data;
        delete curr;
        return tmp;
    }
    int pop(size_t position) {
        if (position > size_ - 2) {
            throw std::runtime_error("Wrong Position!");
        }
        size_--;
        Node* curr = head;
        for (size_t i = 0; i <= position; i++) {
            curr = curr->next;
        }
        curr->next->previous = curr->previous;
        curr->previous->next = curr->next;
        if (curr == tail) {
            tail = curr->previous;
        }
        curr->next = nullptr;
        curr->previous = nullptr;
        int tmp = curr->data;
        delete curr;
        return tmp;
    }
    void push(int value, size_t position) {
        if (position > size_ - 1) {
            throw std::runtime_error("Wrong Position!");
        }
        Node* new_node = new Node();
        new_node->data = value;
        if (head == nullptr) {
            head = new_node;
            tail = head;
            head->next = tail;
            head->previous = tail;
        }
        Node* curr = head;
        for (size_t i = 0; i < position; i++) {
            curr = curr->next;
        }
        new_node->next = curr->next;
        new_node->previous = curr;
        curr->next->previous = new_node;
        curr->next = new_node;
        size_++;
    }

    Node* head{};
    Node* tail{};

private:
    size_t size_;
};