Определить класс: длинное целое число. Создать конструкторы и деструктор

#include <iostream>
#include <conio.h>
 
using namespace std;
 
class Long {
    struct TlistItem
    {
        int Value;
        TlistItem *Next;
    };
    struct Tlist
    {
        TlistItem *First, *Last;
    } List;
    int sz;
    int Num; //номеp 
    static int Kilob; //количество объектов
public: 
    Long(int, int); 
    Long(); 
    Long(const Long&); // конструктор копирования
    ~Long();
    void output() const;
};
int Long::Kilob = 0;
 
Long::Long(int sz, int v)
{
    while (Kilob <= sz) {
        if (List.First == NULL)
        {
            List.First = (TlistItem*)malloc(sizeof(TlistItem));
            List.First->Next = NULL;
            List.First->Value = v;
            List.Last = List.First;
        }
        else
        {
            List.Last->Next = (TlistItem*)malloc(sizeof(TlistItem));
            List.Last->Next->Next = NULL;
            List.Last->Next->Value = v;
            List.Last = List.Last->Next;
        }
        Kilob++;
    }
}
 
Long::Long() {
 
}
Long :: ~Long()
{
    TlistItem *t = List.First, *r;
    while (t != NULL)
    {
        r = t->Next;
        free(t);
        t = r;
    }
    List.First = List.Last = NULL;
}
Long::Long(const Long& Obj) 
{
    
} 
void Long::output() const
{
    TlistItem* k = List.First;
    while (Kilob-- != 0)
    {
        cout << k->Value << " ";
        k = k->Next;
    }
    cout << sz << " " << Kilob << endl;
}
int main()
{
 
    Long list(5, 4);
    list.output();
}

#include <iostream>
#include <algorithm>
#include <iomanip>
template<typename T>
class mylist {
private:
    template<typename NT>
    struct tnode {
        tnode<NT> *next, *prev;
        NT data;
    };
    typedef tnode<T> node;
    node *front, *back;
    size_t sz;
public:
    template<typename TNode>
    class Myiterator : public std::iterator<
        std::input_iterator_tag,
        TNode*,                // value_type= pointer
        size_t,                       // difference_type
        const TNode**,               // pointer
        T                         // reference
    > {
        TNode*  val;
    public:
        explicit Myiterator(TNode*  val_) :val(val_)
        {}
        Myiterator<TNode>& operator++() { val = val->next; return *this; }
        Myiterator<TNode> operator++(int) { Myiterator<TNode> retval = *this; val = val->next; return retval; }
        Myiterator<TNode>& operator--() { val = val->prev; return *this; }
        Myiterator<TNode> operator--(int) { Myiterator<TNode> retval = *this; val = val->prev; return retval; }
        bool operator==(Myiterator other) const { return val == other.val; }
        bool operator!=(Myiterator other) const { return !(*this == other); }
        reference operator*(){ return val->data; }
    };
    typedef Myiterator<node> iterator;
    typedef Myiterator<const node> const_iterator;
 
    mylist(): front(NULL), back(NULL), sz(0) {}
    mylist(size_t count, T value=T()) : front(NULL), back(NULL), sz(0) {
        while(size()!=count)
            push_back(value);
    }
    size_t size() {
        return sz;
    }
    mylist(const mylist& other) : front(NULL), back(NULL), sz(0) {
        for (const_iterator it = other.cbegin(); it != other.cend(); ++it)
            push_back(*it);
    }
    mylist(mylist&& other)
    {
        front = other.front;
        back = other.back;
        sz = other.sz;
        other.back=other.front = NULL;
        other.sz = 0;
    }
    const mylist& operator=(mylist&& other)
    {
        if (this == &other) return *this;
        front = other.front;
        back = other.back;
        sz = other.sz;
        other.back = other.front = NULL;
        other.sz = 0;
        return *this;
    }
    mylist& operator=(const mylist& other) {
        if (this == &other) return *this;
        clear();
        for (const_iterator it = other.cbegin(); it != other.cend(); ++it)
            push_back(*it);
    }
    void push_back(T item)
    {
        ++sz;
        node* nn = new node;
        nn->data = item;
        nn->next = NULL;
        nn->prev = back;
        if (back)
            back->next = nn;
        else 
            front = nn;
        back = nn;
    }
    void push_front(T item)
    {
        ++sz;
        node<T>* nn = new node;
        nn->data = item;
        nn->prev = NULL;
        nn->next = front;
        if (front)
            front->prev = nn;
        else
            back = nn;
        back = nn;
    }
    void clear() {
        sz = 0;
        while (front)
        {
            node* nn = front;
            front = front->next;
            delete nn;
        }
        back = NULL;
    }
    iterator begin() {
        return iterator(front);
    }
    iterator end() {
        return iterator(NULL);
    }
    const_iterator cbegin()const{
        return const_iterator(front);       
    }
    const_iterator cend() const{
        return const_iterator(NULL);
    }
    const_iterator crbegin()const {
        return const_iterator(back);
    }
    const_iterator crend() const {
        return const_iterator(NULL);
    }
    bool empty()
    {
        return sz == 0;
    }
    ~mylist() {
        clear();
    }
};
    const int base = 1e9;
    const int logbase = 9;
class mylong {
    mylist<int> data;
public:
    mylong(int value=0) :data(1, value) {
    }
    mylong operator+(mylong& left)
    {
        mylong retval;
        retval.data.clear();
        int carry = 0;
 
        auto it = data.cbegin(), jt = left.data.cbegin();
        for ( ;it != data.cend() && jt != data.cend(); ++it, ++jt)
        {
            carry += (*it) + (*jt);
            retval.data.push_back(carry%base);
            carry /= base;
        }
        for (; it != data.cend(); ++it)
        {
            carry += *it;
            retval.data.push_back(carry%base);
            carry /= base;
        }
        for (; jt != data.cend(); ++jt)
        {
            carry += *jt;
            retval.data.push_back(carry%base);
            carry /= base;
        }
        if(carry) 
            retval.data.push_back(carry);
        return retval;
    }
    friend std::ostream& operator<< (std::ostream& out, const mylong& value);
};
std::ostream& operator<<(std::ostream& out, const mylong& value)
{
    for (auto it = value.data.crbegin(); it != value.data.crend(); --it)
    {
        out << *it << std::setfill('0') << std::setw(logbase);
    }
    return out;
}
 
#include<vector>
int main() {
    mylong  a = 555555555;
    mylong  b = 666666666;
    mylong  c = a+b;
 
    std::cout << c<<std::endl;
    return 0;
}