Создание класса для оперированием большими числами

#include "stdafx.h"
#include "std_lib_facilities.h"
#include "windows.h"
 
class BigNumber// класс для больших чисел содержит вектор и счетчик кругов для использования
{                    // в циклах. 
public:
    vector<double>numbers;// вектор для большого числа
    int z=1; // счетчик кругов
    void get(int a)                      // функция добавления в вектор числа по разрядам
                                         // на самом деле класс нужен не для записи больших чисел,
    {                                       // а для подсчета факториалов и потом уже для 
        number = a;               // оперирования большими числами. поэтому входные данные через int проходят, 
        if (number <= 9) {                         // наверно можно каждую цифру с потока записывать,
            numbers.push_back(number);   // но я не знаю как это сделать, может кто подскажет.
        }
        if(number>9 && number<=1000000000)
            for (double i = 1000000000; i >= 1; i/10)
            {
                r1 = number / i;
                if (r1 <= 9&&r1>=1) {
                    numbers.push_back(r1);
                    number -= r1*i;
                }
            }
    }
    void out() // вывод числа
    {
        for (int i = 0; i < numbers.size(); i++)
        {
            cout << numbers[i];
        }
    }
private:
    int number;
    int r1;
 
};
//_______________________________________________________
BigNumber REVERS(BigNumber a) // реверс ветора
{
    BigNumber x = a;
    a.numbers.clear();
    for (int i = x.numbers.size() - 1; i < 0; i--)
    {
        a.numbers.push_back(x.numbers[i]);
    }
    return x;
}
//_________________________________________________________
 
int vec2(BigNumber a)    // функция нужна для работы функции Minus  работает с вычитаемым числом
{
    int b = 0;
    int x = a.numbers.size() - a.z; 
    if (x < 0) { error("индикатор значения  ушел в минус"); }
    b = a.numbers[x];
    a.z += 1;  // увеличивает счетчик кругов BigNumber на один
    return b;
}
//_______________________________________________________
void DIVISION(BigNumber a, BigNumber b)
{
 
}
//_______________________________________________________
BigNumber Minus(BigNumber a, BigNumber b)//функция вычитани не доработанна и не работает с отрицательными результатами
{                                        //потом доработаю
    BigNumber x;
    int q; 
    for (int i = a.numbers.size()-1; i > 0||b.z<= b.numbers.size(); i--)
    {
        if ((a.numbers[i] - vec2(b))<0)
        {
            q = a.numbers[i] + 10 - vec2(b);
            x.numbers.push_back(q);
            a.numbers[i - 1] = a.numbers[i - 1] - 1;
        }
        else
        q = a.numbers[i] - vec2(b);
        x.numbers.push_back(q);
    }
    x = REVERS(x);
    b.z = 1;
    return x;
}
//_________________________________________________________
int main()
{
    BigNumber first;
    BigNumber second;
    BigNumber  rezult;
    int f;
    int s;
    while (true)
    {
        cin >> f >> s;
        first.get(f);
        second.get(s);
        rezult = Minus(first, second);
        rezult.out();
    }
    keep_window_open();
    return 0;
}

#ifndef BIGINTEGER_H
#define BIGINTEGER_H
 
#include <vector>
#include <string>
#include <ostream>
#include <iomanip>
#include <sstream>
 
class big_integer {
public:
 
    //---- Конструкторы ----//
    big_integer();
    big_integer(std::string);
    big_integer(signed char);
    big_integer(unsigned char);
    big_integer(signed short);
    big_integer(unsigned short);
    big_integer(signed int);
    big_integer(unsigned int);
    big_integer(signed long);
    big_integer(unsigned long);
    big_integer(signed long long);
    big_integer(unsigned long long);
 
    //---- Арифметические операторы ----//
    friend const big_integer operator +(big_integer, const big_integer&);
    friend const big_integer operator -(big_integer, const big_integer&);
    friend const big_integer operator /(const big_integer&, const big_integer&);
    friend const big_integer operator *(const big_integer&, const big_integer&);
    friend const big_integer operator %(const big_integer&, const big_integer&);
 
    //---- Операторы сравнения ----//
    friend bool operator ==(const big_integer&, const big_integer&);
    friend bool operator <(const big_integer&, const big_integer&);
    friend bool operator !=(const big_integer&, const big_integer&);
    friend bool operator <=(const big_integer&, const big_integer&);
    friend bool operator >(const big_integer&, const big_integer&);
    friend bool operator >=(const big_integer&, const big_integer&);
 
    //---- Составное присваивание ----//
    big_integer& operator +=(const big_integer&);
    big_integer& operator -=(const big_integer&);
    big_integer& operator *=(const big_integer&);
    big_integer& operator /=(const big_integer&);
    big_integer& operator %=(const big_integer&);
 
    friend std::ostream& operator <<(std::ostream&, const big_integer&);
    operator std::string() const;
    const big_integer operator +() const;
    const big_integer operator -() const;
    const big_integer operator ++();
    const big_integer operator ++(int);
    const big_integer operator --();
    const big_integer operator --(int);
 
    const big_integer pow(big_integer) const;
 
private:
    static const int BASE = 1000000000; // основание системы счисления
    std::vector<int> _digits;           // хранилище
    bool _sign;                         // знак числа
 
    void _remove_leading_zeros();
    void _shift_right();
};
#endif // BIGINTEGER_H
#include "biginteger.h"
 
 
big_integer::big_integer() {
    this->_sign = false;
}
 
big_integer::big_integer(std::string str) {
    if (str.length() == 0) {
            this->_sign = false;
    }
    else {
            if (str[0] == '-') {
                    str = str.substr(1);
                    this->_sign = true;
            }
            else {
                    this->_sign = false;
            }
 
            for (long long i = str.length(); i > 0; i -= 9) {
                    if (i < 9)
                            this->_digits.push_back(atoi(str.substr(0, i).c_str()));
                    else
                            this->_digits.push_back(atoi(str.substr(i - 9, 9).c_str()));
            }
 
            this->_remove_leading_zeros();
    }
}
 
void big_integer::_remove_leading_zeros() {
    while (this->_digits.size() > 1 && this->_digits.back() == 0) {
            this->_digits.pop_back();
    }
 
    if (this->_digits.size() == 1 && this->_digits[0] == 0) this->_sign = false;
}
 
std::ostream& operator <<(std::ostream& os, const big_integer& bi) {
    if (bi._digits.empty()) os << 0;
    else {
            if (bi._sign) os << '-';
            os << bi._digits.back();
            char old_fill = os.fill('0');
            for (long long i = static_cast<long long>(bi._digits.size()) - 2; i >= 0; --i) os << std::setw(9) << bi._digits[i];
            os.fill(old_fill);
    }
 
    return os;
}
 
bool operator ==(const big_integer& number1, const big_integer& number2) {
    if (number1._sign != number2._sign) return false;
    if (number1._digits.empty()) {
            if (number2._digits.empty() || (number2._digits.size() == 1 && number2._digits[0] == 0)) return true;
            else return false;
    }
 
    if (number2._digits.empty()) {
            if (number1._digits.size() == 1 && number1._digits[0] == 0) return true;
            else return false;
    }
 
    if (number1._digits.size() != number2._digits.size()) return false;
    for (size_t i = 0; i < number1._digits.size(); ++i) if (number1._digits[i] != number2._digits[i]) return false;
 
    return true;
}
 
const big_integer big_integer::operator +() const {
    return big_integer(*this);
}
 
const big_integer big_integer::operator -() const {
    big_integer copy(*this);
    copy._sign = !copy._sign;
    return copy;
}
 
bool operator <(const big_integer& number1, const big_integer& number2) {
    if (number1 == number2) return false;
    if (number1._sign) {
            if (number2._sign) return ((-number2) < (-number1));
            else return true;
    }
    else if (number2._sign) return false;
    else {
            if (number1._digits.size() != number2._digits.size()) {
                    return number1._digits.size() < number2._digits.size();
            }
            else {
                    for (long long i = number1._digits.size() - 1; i >= 0; --i) {
                            if (number1._digits[i] != number2._digits[i]) return number1._digits[i] < number2._digits[i];
                    }
 
                    return false;
            }
    }
}
 
bool operator !=(const big_integer& number1, const big_integer& number2) {
    return !(number1 == number2);
}
 
bool operator <=(const big_integer& number1, const big_integer& number2) {
    return (number1 < number2 || number1 == number2);
}
 
bool operator >(const big_integer& number1, const big_integer& number2) {
    return !(number1 <= number2);
}
 
bool operator >=(const big_integer& number1, const big_integer& number2) {
    return !(number1 < number2);
}
 
const big_integer operator +(big_integer number1, const big_integer& number2) {
    if (number1._sign) {
            if (number2._sign) return -(-number1 + (-number2));
            else return number2 - (-number1);
    }
    else if (number2._sign) return number1 - (-number2);
    int carry = 0;
    for (size_t i = 0; i < std::max(number1._digits.size(), number2._digits.size()) || carry != 0; ++i) {
            if (i == number1._digits.size()) number1._digits.push_back(0);
            number1._digits[i] += carry + (i < number2._digits.size() ? number2._digits[i] : 0);
            carry = number1._digits[i] >= big_integer::BASE;
            if (carry != 0) number1._digits[i] -= big_integer::BASE;
    }
 
    return number1;
}
 
big_integer& big_integer::operator +=(const big_integer& value) {
    return *this = (*this + value);
}
 
const big_integer big_integer::operator++() {
    return (*this += 1);
}
 
big_integer::operator std::string() const {
    std::stringstream ss;
    ss << *this;
    return ss.str();
}
 
big_integer::big_integer(signed char c) {
    if (c < 0) this->_sign = true;
    else this->_sign = false;
    this->_digits.push_back(std::abs(c));
}
 
big_integer::big_integer(unsigned char c) {
    this->_sign = false;
    this->_digits.push_back(c);
}
 
big_integer::big_integer(signed short s) {
    if (s < 0) this->_sign = true;
    else this->_sign = false;
    this->_digits.push_back(std::abs(s));
}
 
big_integer::big_integer(unsigned short s) {
    this->_sign = false;
    this->_digits.push_back(s);
}
 
big_integer::big_integer(signed int i) {
    if (i < 0) this->_sign = true;
    else this->_sign = false;
    this->_digits.push_back(std::abs(i) % big_integer::BASE);
    i /= big_integer::BASE;
    if (i != 0) this->_digits.push_back(std::abs(i));
}
 
big_integer::big_integer(unsigned int i) {
    this->_digits.push_back(i % big_integer::BASE);
    i /= big_integer::BASE;
    if (i != 0) this->_digits.push_back(i);
}
 
big_integer::big_integer(signed long l) {
    if (l < 0) this->_sign = true;
    else this->_sign = false;
    this->_digits.push_back(std::abs(l) % big_integer::BASE);
    l /= big_integer::BASE;
    if (l != 0) this->_digits.push_back(std::abs(l));
}
 
big_integer::big_integer(unsigned long l) {
    this->_digits.push_back(l % big_integer::BASE);
    l /= big_integer::BASE;
    if (l != 0) this->_digits.push_back(l);
}
 
big_integer::big_integer(signed long long l) {
    if (l < 0) { this->_sign = true; l = -l; }
    else this->_sign = false;
    do {
            this->_digits.push_back(l % big_integer::BASE);
            l /= big_integer::BASE;
    } while (l != 0);
}
 
big_integer::big_integer(unsigned long long l) {
    this->_sign = false;
    do {
            this->_digits.push_back(l % big_integer::BASE);
            l /= big_integer::BASE;
    } while (l != 0);
}
 
const big_integer big_integer::operator ++(int) {
    *this += 1;
    return *this - 1;
}
 
const big_integer big_integer::operator --() {
    return *this -= 1;
}
 
const big_integer big_integer::operator --(int) {
    *this -= 1;
    return *this + 1;
}
 
const big_integer operator -(big_integer number1, const big_integer& number2) {
    if (number2._sign) return number1 + (-number2);
    else if (number1._sign) return -(-number1 + number2);
    else if (number1 < number2) return -(number2 - number1);
    int carry = 0;
    for (size_t i = 0; i < number2._digits.size() || carry != 0; ++i) {
            number1._digits[i] -= carry + (i < number2._digits.size() ? number2._digits[i] : 0);
            carry = number1._digits[i] < 0;
            if (carry != 0) number1._digits[i] += big_integer::BASE;
    }
 
    number1._remove_leading_zeros();
    return number1;
}
 
big_integer& big_integer::operator -=(const big_integer& value) {
    return *this = (*this - value);
}
 
const big_integer operator *(const big_integer& number1, const big_integer& number2) {
    big_integer result;
    result._digits.resize(number1._digits.size() + number2._digits.size());
    for (size_t i = 0; i < number1._digits.size(); ++i) {
            int carry = 0;
            for (size_t j = 0; j < number2._digits.size() || carry != 0; ++j) {
                    long long cur = result._digits[i + j] +
                            number1._digits[i] * 1LL * (j < number2._digits.size() ? number2._digits[j] : 0) + carry;
                    result._digits[i + j] = static_cast<int>(cur % big_integer::BASE);
                    carry = static_cast<int>(cur / big_integer::BASE);
            }
    }
 
    result._sign = number1._sign != number2._sign;
    result._remove_leading_zeros();
    return result;
}
 
big_integer& big_integer::operator *=(const big_integer& value) {
    return *this = (*this * value);
}
 
 
void big_integer::_shift_right() {
    if (this->_digits.size() == 0) {
            this->_digits.push_back(0);
            return;
    }
    this->_digits.push_back(this->_digits[this->_digits.size() - 1]);
    for (size_t i = this->_digits.size() - 2; i > 0; --i) this->_digits[i] = this->_digits[i - 1];
    this->_digits[0] = 0;
}
 
 
const big_integer operator /(const big_integer& number1, const big_integer& number2) {
    if (number2 == 0)
        return 0;
    big_integer b = number2;
    b._sign = false;
    big_integer result, current;
    result._digits.resize(number1._digits.size());
    for (long long i = static_cast<long long>(number1._digits.size()) - 1; i >= 0; --i) {
            current._shift_right();
            current._digits[0] = number1._digits[i];
            current._remove_leading_zeros();
            int x = 0, l = 0, r = big_integer::BASE;
            while (l <= r) {
                    int m = (l + r) / 2;
                    big_integer t = b * m;
                    if (t <= current) {
                            x = m;
                            l = m + 1;
                    }
                    else r = m - 1;
            }
 
            result._digits[i] = x;
            current = current - b * x;
    }
 
    result._sign = number1._sign != number2._sign;
    result._remove_leading_zeros();
    return result;
}
 
big_integer& big_integer::operator /=(const big_integer& value) {
    return *this = (*this / value);
}
 
const big_integer operator %(const big_integer& number1, const big_integer& number2) {
    big_integer result = number1 - (number1 / number2) * number2;
    if (result._sign) result += number2;
    return result;
}
 
big_integer& big_integer::operator %=(const big_integer& value) {
    return *this = (*this % value);
}
 
 
const big_integer big_integer::pow(big_integer n) const {
    big_integer a(*this), result(1);
    while (n != 0) {
            if (n._digits[0] & 1) result *= a;
            a *= a;
            n /= 2;
    }
 
    return result;
}