大数的有效素数分解

我一直在处理一个小问题，需要将18位数字计算成它们各自的素数分解。考虑到它确实有效，所有的东西都编译了，运行得很好，但我希望减少素数分解的运行时间。我已经实现了递归和线程，但我认为我可能需要一些帮助来理解可能的大量计算算法。

每次我在我预先制作的4个数字上运行这个程序，大约需要10秒。如果有任何想法的话，我想把这个时间减少到0.06秒。

我注意到一些算法，比如埃拉托斯梯尼筛，并在计算之前生成所有素数的列表。我只是想知道是否有人能详细说明一下。例如，我在理解如何在我的程序中实现埃拉托斯尼筛方面存在问题，或者这是否是一个好主意。任何关于如何更好地解决这一问题的建议都将非常有用！

这是我的代码：

#include <iostream>
#include <thread>
#include <vector>
#include <chrono>
using namespace std;
using namespace std::chrono;
vector<thread> threads;
vector<long long> inputVector;
bool developer = false; 
vector<unsigned long long> factor_base;
vector<long long> primeVector;
class PrimeNumber
{
    long long initValue;        // the number being prime factored
    vector<long long> factors;  // all of the factor values
public:
    void setInitValue(long long n)
    {
        initValue = n;
    }
    void addToVector(long long m)
    {
        factors.push_back(m);
    }
    void setVector(vector<long long> m)
    {
        factors = m;
    }
    long long getInitValue()
    {
        return initValue;
    }
    vector<long long> getVector()
    {
        return factors;
    }
};
vector<PrimeNumber> primes;
// find primes recursively and have them returned in vectors
vector<long long> getPrimes(long long n, vector<long long> vec)
{
    double sqrt_of_n = sqrt(n);
    for (int i = 2; i <= sqrt_of_n; i++)
    {
        if (n % i == 0) 
        {
            return vec.push_back(i), getPrimes(n / i, vec); //cause recursion
        }
    }
    // pick up the last prime factorization number
    vec.push_back(n);
    //return the finished vector
    return vec;
}
void getUserInput()
{
    long long input = -1;
    cout << "Enter all of the numbers to find their prime factors. Enter 0 to compute" << endl;
    do
    {
        cin >> input;
        if (input == 0)
        {
            break;
        }
        inputVector.push_back(input);
    } while (input != 0);
}
int main() 
{
    vector<long long> temp1;   // empty vector
    vector<long long> result1; // temp vector
    if (developer == false)
    {
        getUserInput();
    }
    else
    {
        cout << "developer mode active" << endl;
        long long a1 = 771895004973090566;
        long long b1 = 788380500764597944;
        long long a2 = 100020000004324000;
        long long b2 = 200023423420000000;
        inputVector.push_back(a1);
        inputVector.push_back(b2);
        inputVector.push_back(b1);
        inputVector.push_back(a2);
    }
    high_resolution_clock::time_point time1 = high_resolution_clock::now();
    // give each thread a number to comput within the recursive function
    for (int i = 0; i < inputVector.size(); i++)
    {   
        PrimeNumber prime;
        prime.setInitValue(inputVector.at(i));
        threads.push_back(thread([&]{
            prime.setVector(result1 = getPrimes(inputVector.at(i), temp1));
            primes.push_back(prime);
        }));
    }
    // allow all of the threads to join back together.
    for (auto& th : threads)
    {
        cout << th.get_id() << endl;
        th.join();
    }
    high_resolution_clock::time_point time2 = high_resolution_clock::now();
    // print all of the information
    for (int i = 0; i < primes.size(); i++)
    {
        vector<long long> temp = primes.at(i).getVector();
        for (int m = 0; m < temp.size(); m++)
        {
            cout << temp.at(m) << " ";
        }
        cout << endl;
    }
    cout << endl;
    // so the running time
    auto duration = duration_cast<microseconds>(time2 - time1).count();
    cout << "Duration: " << (duration / 1000000.0) << endl;
    return 0;
}