Кольцевой двусвязный список. Есть ошибки в коде

#include <iostream>
using namespace std;
struct Double_node{ 
    int val;
    Double_node* next;
    Double_node* prev;
};
class Double_list {
private:
    Double_node* tail= nullptr;
    int sz=1;
public:
    Double_list() { tail = new Double_node();
    tail->next = tail;
    tail->prev = tail;
    }
    Double_list(int x) {
        Double_node* t = new Double_node();
        t->next = t;
        t->prev = t;
            t->val = x;
    }
    ~Double_list() {}
        void push_front(int x) {
            Double_node*cur = tail -> next;
            tail->next = new Double_node(x,cur,tail);
    }
        void push_back(int x) {
            Double_node* cur = tail->prev;
            tail->prev = new Double_node(x, tail, cur);
            }
        void pop_back() {
            Double_node* cur = tail->prev->prev;
            delete tail->prev;
            tail->prev = cur;
            cur->next = tail;
        }
        void pop_front() {
            Double_node* cur = tail->next->next;
            delete tail->next;
            tail->next = cur;
            cur->prev = tail;
        }
 
        bool empty() { 
            if (tail->next = tail) return true;
            else return false;
        }
        int size() {
            Double_node* cur = tail->next;
            while (cur != tail)
            {
                sz++;
                cur = cur->next;
            }
            return sz;
        }
        void clear() {}
        int& front() { return tail->next->val; }
        int& back() { return tail->prev->val; }
        void print() {
            Double_node* cur = tail->next;
            while (cur != tail)
            {
                cout << cur->val << endl;
                cur = cur->next;
            }
        }
    };
 
int main()
{
    Double_list a;
    Double_list zz;
    cout << zz.size;
 
    return 0;
}

cout << zz.size();

 ~Double_list() {}

#include <iostream>
 
using namespace std;
 
struct Double_node {
    int val;
    Double_node* next;
    Double_node* prev;
};
 
class Double_list {
private:
    Double_node* tail = nullptr;
    size_t sz = 0;
public:
    Double_list() = default;
    Double_list(const Double_list&) = delete;
    Double_list& operator=(const Double_list&) = delete;
 
    explicit Double_list(int x) : Double_list()
    {
        push_back(x);
    }
        
    ~Double_list()
    {
        clear();
    }
 
    void push_front(int x) {
        if (tail)
        {
            Double_node* cur = new Double_node{ x, tail->next, tail };
            tail->next = tail->next->prev = cur;
        }
        else
        {
            tail = new Double_node{ x };
            tail->next = tail->prev = tail;
        }
        ++sz;
    }
    void push_back(int x) {
        push_front(x);
        tail = tail->next;
    }
    void pop_back() {
        if (sz > 1)
        {
            Double_node* cur = tail;
            tail = tail->prev;
            tail->next = cur->next;
            cur->next->prev = tail;
            delete cur;
        }
        else
        {
            delete tail;
            tail = nullptr;
        }
        --sz;
    }
    void pop_front() {
        tail = tail->next;
        pop_back();
    }
 
    bool empty() const {
        return sz;
    }
    size_t size() const {
    
        return sz;
    }
 
    void clear() {
        Double_node* cur = tail->next;
        while (cur != tail)
        {
            Double_node* to_del = cur;
            cur = cur->next;
            delete to_del;
        }
        delete tail;
        tail = nullptr;
        sz = 0;
    }
 
    int& front()
    {
        if (sz) return tail->next->val;
        throw std::runtime_error{ __FUNCTION__ };
    }
    int& back()
    {
        if (sz) return tail->val;
        throw std::runtime_error{ __FUNCTION__ };
    }
    void print() const {
        if (tail)
        {
            Double_node* cur = tail->next;
            while (cur != tail)
            {
                cout << cur->val << ' ';
                cur = cur->next;
            }
            cout << cur->val << endl;
        }
        else
        {
            cout << "empty\n";
        }
    }
};
 
int main()
{
    Double_list a;
    for (int i{}; i < 5; ++i) a.push_back(i);
    a.print();
 
    for (int i{}; i < 5; ++i) a.push_front(i);
    a.print();
 
    a.pop_front();
    a.print();
 
    a.pop_back();
    a.print();
 
    a.clear();
    a.print();
 
    try
    {
        cout << a.back() << endl;
    }
    catch (const std::runtime_error& err)
    {
        cerr << "exception: " << err.what() << '\n';
    }
 
    return 0;
}