Получить сумму двух целых чисел, представленных двусвязными списками

#include <iostream>
#include <conio.h>
#include <list>
 
using namespace std;
 
int end(int&& ret = 0){cout << "\nEND\n"; _getch(); return ret;}
 
class long_num
{
    list<int> num;
    void cfzs()
    { while(num.size() > 1 && num.front() == 0) num.pop_front(); }
public:
    long_num();
    long_num(int);
    long_num operator+(long_num&);
    long_num& operator=(int);
    friend ostream& operator<<(ostream& out, long_num& ln);
};
 
long_num::long_num()
{
}
 
long_num::long_num(int in)
{
    *this = in;
}
 
long_num long_num::operator + (long_num& in)
{
    long_num temp;//шо будем возвращать
    auto itin = in.num.rbegin(), itn = num.rbegin();//итераторы для прохода по листам с конца
    
    temp.num.push_front(0);//запихиваем первое значение - 0
    while(itin != in.num.rend() && itn != num.rend())//пока не дойдем до чьего-нибудь конца
    {
        temp.num.front() += *itin + *itn; //прибавляем сумму поселдних двух цифр 
        if(temp.num.front() >= 10)//если сумма больше или равна 10,
        {
            temp.num.front() -= 10;//то вычитаем из текущего эл. 10
            temp.num.push_front(1);//а в начало пихаем 1
        }
        else//если результат меньше 10,
        {
            temp.num.push_front(0);//то просто добавляем новый разряд
        }
        itin++;//переходим на след. эл
        itn++;
    }
    if(itin != in.num.rend())//проверяем, осталось ли что-нибудь во входном num'е
    {
        itn = itin;//если да, то переводим итератор itn на текущую позицию itin
        itin = in.num.rend();//и itin устанавливаем как конец
    }
    else if(itn != num.rend())//проверяем, раз ничего во входном num'е, то может быть в this->num'е что-то осталось
        itin = num.rend();//если да, то ставим конец this->num в itin
    else//если оба num'a кончились, то просто приравниваем итераторы
        itin = itn;
 
    if(itn != itin)//если итераторы не равно => что-то надо дозаписать
    {
        temp.num.front() += *itn;//прибавляем к текущему значение то, что осталось
        itn++;//переходим 
        while(itn != itin)//и далее по циклу
        {
            temp.num.push_front(*itn);//пихаем в начало, что осталось
            itn++;//переход на след. эл.
        }
    }
    temp.cfzs();//удаляем нули в начале
    return temp;//возвращаем
}
 
long_num& long_num::operator=(int a)
{
    while(a)
    {
        num.push_front(a % 10);
        a /= 10;
    }
    return *this;
}
 
ostream& operator<<(ostream& out, long_num& ln)
{
    for(auto i : ln.num)
        cout << i;
    return out;
}
 
int main()
{
    long_num a, b;
    a = 15;
    b = 14;
    cout << "a = " << a << endl << "b = " << b << endl << "a + b = " << a + b;
 
    return end();
}

#include <iostream>
#include <conio.h>
//#include <list>
 
using namespace std;
 
int end(int&& ret = 0) { cout << "\nEND\n"; _getch(); return ret; }
 
class long_num
{
    class longn_list
    {
    protected:
        struct worm//узел
        {
            int val;//значение
            worm *next, *prev;//указатель на след. и пред. эл.
        } *head, *tail;//хвост с головой
    public://работу методов расписывать не буду, надеюсь вы знаете как работают двусвязые списки
        longn_list();//конструктор п/у.
        longn_list(longn_list&);//конструктор по инициализации текущего объекта, др объектом этого же класс
        virtual ~longn_list();//деструктор
        void clear();//функция очистки
        void push_front(int);//добавление в начало
        void push_back(int);//добавление в конец
        void pop_front();//удаление из начала
        int& front();//доступ к первому эл.
        int& back();//доступ к последнему эл.
        bool empty();//пуст ли лист
 
        class iterator;//обычный итератор
        iterator begin() const { return iterator(head); }//итератор на начало - голова
        iterator end() const { return iterator(nullptr); }//итератор на конец - хвост+1
        void insert(iterator&, int);
        class iterator//реализация обычного итератора
        {
            worm* cur;//указатель
        public:
            iterator()//пустой конструктор
            {
            }
 
            ~iterator()//пустой деструктор
            {
            }
 
            iterator(worm* in) : cur(in)//консутруктор копирования адреса
            {
            }
 
            iterator(iterator& in)//конструктор инициализирющий указатель по указателю in
            {
                cur = in.cur;//инициализируем cur адресом указателя in.cur
            }
 
            iterator& operator=(worm* in)//перегрузка оператора присваивания по структуре узла
            {
                cur = in;//присваиваем нашему указателю адрес in
                return *this;
            }
 
            iterator& operator=(iterator& in)//перегрузка оператора присваивания по классу iterator
            {
                cur = in.cur;//присваиваем нашему указателю адрес in.cur
                return *this;
            }
 
            iterator& operator++(int)//перегрузка постфиксной инкременции
            {
                if(cur == nullptr)//если мы уже в самом конце а нас просят идти дальше,
                    throw "out of range";//то кидаем исключение о вылете за предел
                cur = cur->next;//переходим на след. эл.
                return *this;
            }
 
            iterator& operator--(int)//перегрузка постфиксной декременции
            {
                if(cur == nullptr)//если мы уже в самом конце а нас просят идти дальше,
                    throw "out of range";//то кидаем исключение о вылете за предел
                cur = cur->prev;//переходим на пред. эл.
                return *this;
            }
 
            iterator& operator++()//перегрузка префиксной инкременции
            {
                if(cur == nullptr)//если мы уже в самом конце а нас просят идти дальше,
                    throw "out of range";//то кидаем исключение о вылете за предел
                cur = cur->next;//переходим на след. эл.
                return *this;
            }
 
            iterator& operator--()//перегрузка префиксной декременции
            {
                if(cur == nullptr)//если мы уже в самом конце а нас просят идти дальше,
                    throw "out of range";//то кидаем исключение о вылете за предел
                cur = cur->prev;//переходим на пред. эл.
                return *this;
            }
 
            int& operator*()//перегрузка оператора разыменовывания
            {
                return cur->val;//возвращает ссылку на значение, которе лежит по данному итератору
            }
            const int& operator*() const //константаня перегрузка оператора*
            {
                return cur->val;//возвращает ссылку на значение, которе лежит по данному итератору
            }
 
            bool operator!=(iterator& oi)//перегрузка оператора неравенства
            {
                return cur != oi.cur;//true, если наш указатель не указывает туда же, куда и указатель oi
            }
 
            bool operator==(iterator& oi)//перегрузка оператора равенства
            {
                return cur == oi.cur;//true, если наш указатель указывает туда же, куда и указатель oi
            }
        };
        
        class riterator;//обратны итератор, работает точно также, только идет не с начла до конца, а от конца к началу
        riterator rbegin() const { return riterator(tail); }//обратный итератор на начало - хвост
        riterator rend() const { return riterator(nullptr); }//обратный итератор на конец - голова-1
        class riterator
        {
            worm* cur;
        public:
            riterator()
            {
            }
 
            ~riterator()
            {
            }
 
            riterator(worm* in) : cur(in)
            {
            }
 
            riterator(riterator& in)
            {
                cur = in.cur;
            }
 
            riterator& operator=(worm* in)
            {
                cur = in;
                return *this;
            }
 
            riterator& operator=(riterator& in)
            {
                cur = in.cur;
                return *this;
            }
 
            riterator& operator++(int)
            {
                if(cur == nullptr)
                    throw "out of range";
                cur = cur->prev;
                return *this;
            }
 
            riterator& operator--(int)
            {
                if(cur == nullptr)
                    throw "out of range";
                cur = cur->next;
                return *this;
            }
 
            riterator& operator++()
            {
                if(cur == nullptr)
                    throw "out of range";
                cur = cur->prev;
                return *this;
            }
 
            riterator& operator--()
            {
                if(cur == nullptr)
                    throw "out of range";
                cur = cur->next;
                return *this;
            }
 
            int& operator*()
            {
                return cur->val;
            }
            const int& operator*() const
            {
                return cur->val;
            }
 
            bool operator!=(riterator& oi)
            {
                return cur != oi.cur;
            }
 
            bool operator==(riterator& oi)
            {
                return cur == oi.cur;
            }
        };
    }num;//создаем класс longn_list и один его объект
    void cfzs()
    { while(num.empty() != true && num.front() == 0) num.pop_front(); }
public:
    long_num();
    long_num(int);
    long_num operator+(long_num&);
    long_num& operator=(int);
    friend ostream& operator<<(ostream& out, long_num& ln);
};
 
long_num::long_num()
{
}
 
long_num::long_num(int in)
{
    *this = in;
}
 
long_num long_num::operator + (long_num& in)
{
    long_num temp;//шо будем возвращать
    auto itin = in.num.rbegin(), itn = num.rbegin();//итераторы для прохода по листам с конца
 
    temp.num.push_front(0);//запихиваем первое значение - 0
    while(itin != in.num.rend() && itn != num.rend())//пока не дойдем до чьего-нибудь конца
    {
        temp.num.front() += *itin + *itn; //прибавляем сумму поселдних двух цифр 
        if(temp.num.front() >= 10)//если сумма больше или равна 10,
        {
            temp.num.front() -= 10;//то вычитаем из текущего эл. 10
            temp.num.push_front(1);//а в начало пихаем 1
        }
        else//если результат меньше 10,
        {
            temp.num.push_front(0);//то просто добавляем новый разряд
        }
        itin++;//переходим на след. эл
        itn++;
    }
    if(itin != in.num.rend())//проверяем, осталось ли что-нибудь во входном num'е
    {
        itn = itin;//если да, то переводим итератор itn на текущую позицию itin
        itin = in.num.rend();//и itin устанавливаем как конец
    }
    else if(itn != num.rend())//проверяем, раз ничего во входном num'е, то может быть в this->num'е что-то осталось
        itin = num.rend();//если да, то ставим конец this->num в itin
    else//если оба num'a кончились, то просто приравниваем итераторы
        itin = itn;
 
    if(itn != itin)//если итераторы не равно => что-то надо дозаписать
    {
        temp.num.front() += *itn;//прибавляем к текущему значение то, что осталось
        itn++;//переходим 
        while(itn != itin)//и далее по циклу
        {
            temp.num.push_front(*itn);//пихаем в начало, что осталось
            itn++;//переход на след. эл.
        }
    }
    temp.cfzs();//удаляем нули в начале
    return temp;//возвращаем
}
 
long_num& long_num::operator=(int a)
{
    while(a)
    {
        num.push_front(a % 10);
        a /= 10;
    }
    return *this;
}
 
ostream& operator<<(ostream& out, long_num& ln)
{
    for(auto i : ln.num)
        cout << i;
    return out;
}
 
long_num::longn_list::longn_list() { head = tail = nullptr; }
 
long_num::longn_list::longn_list(longn_list& in)
{
    head = tail = nullptr;
    for(auto& i : in)
        push_back(i);
}
 
long_num::longn_list::~longn_list() { clear(); }
 
void long_num::longn_list::clear()
{
    while(head)
    {
        tail = head;
        head = head->next;
        delete tail;
    }
    tail = head = nullptr;
}
 
void long_num::longn_list::push_front(int a)
{
    if(head != nullptr)
    {
        head->prev = new worm;
        head->prev->next = head;
        head = head->prev;
    }
    else
    {
        head = new worm;
        tail = head;
        head->next = nullptr;
    }
    head->prev = nullptr;
    head->val = a;
}
 
void long_num::longn_list::push_back(int a)
{
    if(tail != nullptr)
    {
        tail->next = new worm;
        tail->next->prev = tail;
        tail = tail->next;
    }
    else
    {
        tail = new worm;
        head = tail;
        tail->prev = nullptr;
    }
    tail->next = nullptr;
    tail->val = a;
}
 
void long_num::longn_list::pop_front()
{
    if(head == nullptr)
        throw "list is empty";
    worm* temp = head;
    head = head->next;
    head->prev = nullptr;
    delete temp;
}
 
int& long_num::longn_list::front()
{
    if(head == nullptr)
        throw "list is empty";
    return head->val;
}
 
int& long_num::longn_list::back()
{
    if(head == nullptr)
        throw "list is empty";
    return head->val;
}
 
bool long_num::longn_list::empty() { return head == nullptr; }
 
int main()
{
    long_num a, b;
    a = 15;
    b = 144;
    cout << "a = " << a << endl << "b = " << b << endl << "a + b = ";
    cout << a + b;
 
    return end();
}