Число, хранящееся в виде массива множителей

/**
 * Класс Variable реализует целое положительное число,
 * представленное в виде массива его простых множителей.
 *
 * Так же перегружены основные операторы (+ - * /)
 */


#pragma once
#include <vector>
#include <iostream>
#include <algorithm>


using std::vector;
using std::ostream;


// Получить массив простых множителей числа
vector<int> getPrimeFactors(int var) {
    vector<int> result;
    int div = 2;
    while (var > 1) {
        while (var % div == 0) {
            result.push_back(div);
            var = var / div;
        }
        // Из четных простых делителей числа может быть только 2
        if (div == 2) div++;
        else div += 2;
    }
    return result;
}


class Variable {
private:
    vector<int> _dividers; // Массив с делителями числа
    int _sign = +1; // Знак числа (либо +1, либо -1)

public:
    Variable(int var) {
        // Если передали 0
        if (var == 0) {
            _dividers.push_back(0);
            return;
        }

        // Если передали отризательное число
        if (var < 0) {
            _sign = -1;
            var = -var;
        }
        _dividers = getPrimeFactors(var);
    }

    Variable(vector<int> &dividers, int sign) {
        _dividers = dividers;
        _sign = sign;
    }

    vector<int> getDividers() const {
        return _dividers;
    }

    int toInt() const {
        int result = _sign;
        // Умножаем знак на каждое число в векторе
        std::for_each(_dividers.begin(), _dividers.end(), [&](int n) { result *= n; });
        return result;
    }

    int getSign() const {
        return _sign;
    }

    // Перегружаем операторы основных операций
    Variable operator+(const Variable &variable) const {
        return Variable(toInt() + variable.toInt());
    }

    Variable operator-(const Variable &variable) const {
        return Variable(toInt() - variable.toInt());
    }

    Variable operator*(const Variable &variable) const {
        vector<int> dividers = variable.getDividers();
        // Добавляем множители из текущей переменной
        dividers.insert(dividers.end(), _dividers.begin(), _dividers.end());

        int sign = _sign * variable.getSign();

        Variable newVar(dividers, sign);
        return newVar;
    }

    Variable operator/(const Variable &variable) const {
        return Variable(toInt() / variable.toInt());
    }
};

// Перегружаем оператор вывода
ostream& operator << (ostream& ostream, const Variable &variable) {
    ostream << variable.toInt();
    return ostream;
}




/**
 * Пример Main.cpp
 */
#include <iostream>
#include "Variable.hpp"

int main() {
    Variable first(12);
    Variable second(4);

    Variable result = first / second;

    std::cout << result << std::endl;
    system("pause");

    return 0;
}