Помогите разобраться с кодом. Класс, описывающий длинное вещественное число.

#include <deque>
#include <string>
#include <algorithm>
#include <vector>
 
using namespace std;
 
// Класс, описывающий длинное вещественное число
class LongNumber
{
public:
    // Контейнер, содержащия цифры в десятичной записи числа
    deque<char> number;
    // Длина вещественной части числа
    int fraction;
    // Корректно ли число
    bool error;
    // Отрицательное ли число
    bool minus;
 
    // Конструктор класса
    LongNumber(string number)
    {
        // Устанавливаем длину вещественной части равной нулю
        fraction = 0;
        // Число корректно и не отрицательно
        error = minus = false;
        // Преобразуем число из строки во внутреннее представление
        for(int i = 0;i < number.size();++i)
            // Если символ '-'
            if(number[i] == '-')
                // Установить флаг
                minus = true;
            // Если встретился разделитель
            else if(number[i] == '.')
                // Установить длину вещественной части
                this->fraction = number.size() - i - 1;
            // Иначе
            else
                // Занести в цифру в контейнер
                this->number.push_back(number[i] - '0');
        // Удалить ведущие и конечные нули
        erase_zeros();
    }
 
    // Перегрузка оператора сравнения (без учета знака)
    int operator<=(const LongNumber &b)
    {
        // Если длина первого числа меньше второго
        if(number.size() - fraction < b.number.size() - b.fraction)
            // Вернуть единицу
            return 1;
        // Если длина первого числа больше второго
        if(number.size() - fraction > b.number.size() - b.fraction)
            // Вернуть ноль
            return 0;
        // Сравниваем посимвольно
        for(int i = 0;i < number.size() && i < b.number.size();++i)
            // Если текущие символы не равны
            if(number[i] != b.number[i])
                // Сравнить их и вернуть результат
                return number[i] <= b.number[i];
        // Вернуть единицу (цисла равны)
        return 1;
    }
 
    // Перегрузка оператора вычитания длинных чисел
    LongNumber operator-(LongNumber b)
    {
        // Создаем длинное число для результата вычитания
        LongNumber tmp("0");
        // Очищаем список цифр
        tmp.number.clear();
        // Выравниваем длину дробной части делимого
        while(fraction < b.fraction)
            number.push_back(0), fraction++;
        // Выравниваем длину дробной части делителя
        while(fraction > b.fraction)
            b.number.push_back(0), b.fraction++;
        // Задаем длину дробной части результата
        tmp.fraction = fraction;
        // Пока второе число короце первого
        while(number.size() != b.number.size())
            // Дополняем ведущими нулями второе число
            b.number.push_front(0);
        // Создаем переменную для хранения информации о заеме в старшем разряде
        int p = 0;
        // Выполняем посимвольное вычитание от младших разрядов к старшим
        for(int i = number.size() - 1;i >= 0;--i)
            // Если цифра в текущем разряде вычитаемого больше чем у уменьшаемого
            if(b.number[i] > number[i] - p)
            {
                // Производим вычитание
                tmp.number.push_front(number[i] + 10 - p - b.number[i]);
                // Указываем, что был заем в старшем разряде
                p = 1;
            }
            // Иначе
            else
            {
                // Производим вычитание
                tmp.number.push_front(number[i] - p - b.number[i]);
                // Указываем, что заем не производился
                p = 0;
            }
        // Возвращаем результат вычитания, предварительно удалив ведущие нули
        return tmp.erase_zeros();
    }
 
    // Функция, которая умножает число на 10 и прибавляет к младшему разряду цифру b
    LongNumber mult_and_add(int b)
    {
        // Помещаем цифру в конец числа
        number.push_back(b);
        // Возвращаем результат, предварительно удалив нули
        return this->erase_zeros();
    }
 
    // Удаление ведущих и конечных нулей
    LongNumber erase_zeros()
    {
        // Пока в конце числа есть ноль и длина вещественной части больше нуля
        while(number.back() == 0 && fraction > 0)
        {
            // Удаляем ноль с конца
            number.pop_back();
            // Уменьшаем длину вещественной части
            fraction--;
        }
        //  Пока в начале числа есть ноль и длина числа больше единицы
        while(number.front() == 0 && number.size() > 1)
            // Удаляем ноль с начала
            number.pop_front();
        // Если число меньше единицы, а ведущего нуля в записи нет
        if(number.size() == fraction)
            // Добавить ведущий ноль
            number.push_front(0);
        // Вернуть результат
        return *this;
    }
 
    // Преобразование длинного числа в строку
    string to_str()
    {
        // Создаем переменную для хранения результата
        string res;
        // Если чесло отрицательное
        if(minus)
            // Поместить в строку знак '-'
            res += '-';
        // Для каждого числа из списка
        for(int i = 0;i < number.size();++i)
        {
            // Если оставшаяся длин равна длине вещественной части
            if(number.size() - i == fraction)
                // Добавить к строке символ разделителя
                res += ".";
            // Добавить к результату текущую цифру
            res += '0' + number[i];
        }
        // Вернуть полученную строку
        return res;
    }
};
 
// Функция для вычисления остатка от деления a на b
LongNumber mod(LongNumber a, LongNumber b)
{
    // Создаем длинное число для результата
    LongNumber res("0");
    // Если число b - ноль
    if(b.number.size() == 1 && b.number[0] == 0)
    {
        // Установить флаг ошибки
        res.error = true;
        // Вернуть результат
        return res;
    }
    // Находим на сколько можно уменьшить дробную часть
    int shift = min(a.fraction, b.fraction);
    // Запоминаем длину дробной часли делителя
    int len = b.fraction;
    // Уменьшаем дробную часть
    a.fraction -= shift;
    // Уменьшаем дробную часть
    b.fraction -= shift;
    // Пока дробная часть второго числа не равна нулю
    while(b.fraction > 0)
    {
        // Уменьшаем дробную часть
        b.fraction--;
        // Добавляем в конец первого числа ноль
        a.number.push_back(0);
    }
    // Идем по цифрам делимого
    for(int i = 0;i < a.number.size() - a.fraction;++i)
    {
        // Дописываем в конец результата текущую цифру 
        res.mult_and_add(a.number[i]);
        // Пока делитель меньше либо равен результату
        while(b <= res)
            // Вычитаем из результата делитель
            res = res - b;
    }
    // Идем по цифрам дробной части делимого
    for(int i = a.number.size() - a.fraction;i < a.number.size();++i)
        // Дописываем их к результату
        res.number.push_back(a.number[i]);
    // Устанавливаем длину дробной части результата
    res.fraction = a.fraction + len;
    // Если делимое и делитель отрицательны
    if(a.minus && b.minus)
        // Результат отрицательный
        res.minus = true;
    // Если делимое отрицательное
    else if(a.minus)
        // Результат равен разности делителя и текущего результата
        res = b - res;
    // Если делитель отрицательный
    else if(b.minus)
    {
        // Результат равен разности делителя и текущего результата
        res = b - res;
        // Со знаком минус
        res.minus = true;
    }
    // Вернуть результат, убрав ненужные нули
    return res.erase_zeros();
}
 
// Функция для нахождения остатков набора пар чисел
vector<LongNumber> calculate(vector<pair<LongNumber, LongNumber> > data)
{
    // Создаем контейнер для хранения результата
    vector<LongNumber> result;
    // Для каждой пары из набора
    for(int i = 0;i < data.size();++i)
        // Найти остаток и поместить его в результат
        result.push_back(mod(data[i].first, data[i].second));
    // Вернуть результат
    return result;
}

// Контейнер, содержащия цифры в десятичной записи числа
    deque<char> number;