Как получить результат потоков в массиве ?

#include <thread>
#include <future>
#include <iostream>
using namespace std;
int Matrix_NxN(int** array, int col);
void matrixUpdate(int** mass, int** mass2, int i, int j, int col);
auto funk(int** array, int col);
 
int main(){
    system("chcp 1251");
    system("cls");
    int col, result, n;
    int** mass, int** p;
    cout << "Размер матрицы ";
    cin >> col;
    mass = new int* [col];
    for (int i = 0; i < col; i++) {
        mass[i] = new int[col];
        for (int j = 0; j < col; j++) {
            mass[i][j] = rand() % 50 + 1;
        }
    }
    p = new int* [col];
    for (int i = 0; i < col; i++)
        p[i] = new int[col];
    n = col - 1;
    for (int i = 0; i < col; i++) {
        matrixUpdate(mass, p, i, 0, col);
        result = funk(p, n);
    }
    //cout << "Определитель равен " << result;
    //cin.get();
    return 0;
}
auto funk(int** array, int col) {
    for (int i = 0; i < col; i++) {
        auto res = async(launch::async, [array, col]{
            Matrix_NxN(array,col);
         });
        return res;
    } 
}
 
int Matrix_NxN(int** array, int col) {
    int i = 0, j = 0, d = 0, k = 1, n = col - 1;
    int** pArray;
    pArray = new int* [col];
    for (int i = 0; i < col; i++)
        pArray[i] = new int[col];
    n = col - 1;
    if (col < 1)
        cout << "Определителя нет!";
    else if (col == 1){
        d = array[0][0];
        return (d);
    }
    else if (col == 2){
        d = array[0][0] * array[1][1] - (array[1][0] * array[0][1]);
        return (d);
    }
    else{
        for (i = 0; i < col; i++){
            matrixUpdate(array, pArray, i, 0, col);
            d = d + k * array[i][0] * Matrix_NxN(pArray, n);
            k = -k;
        }
    }
    return (d);
}
 
 
void matrixUpdate(int** mass, int** mass2, int i, int j, int col){
    int c1, c2, num1 = 0, num2;
    for (c1 = 0; c1 < col - 1; c1++){
        if (c1 == i)
            num1 = 1;
        num2 = 0;
        for (c2 = 0; c2 < col - 1; c2++){
            if (c2 == j)
                num2 = 1;
            mass2[c1][c2] = mass[c1 + num1][c2 + num2];
        }
    }
}

#include <thread>
#include <iostream>
#include <vector>
#include <utility>
#include <queue>
#include <atomic>
#include <cmath>
 
using matrix = std::vector<std::vector<int>>;
using pair = std::pair<int, matrix>;
 
int main() 
{
    matrix mtx
    {
        {2,2,3,33},
        {5,66,7,8},
        {1,2,3,4},
        {5,6,7,8},
    };
 
    std::queue<pair> que;
    que.push({1, mtx});
    std::atomic_flag af = ATOMIC_FLAG_INIT;
    std::atomic_int res = 0;
    std::atomic_int goOn = 1;
    for (int i = 1; i <= mtx.size(); ++i)
    {
        goOn = goOn * i;
    }
 
    auto lMatrixMinusOneOrder = [&que, &af, &res, &goOn]() // функция потока
    {
        while (goOn)
        {
            pair pr;
            while (goOn)
            {
                while (af.test_and_set()) {}
                if (!que.empty())
                {
                    pr = std::move(que.front());
                    que.pop();
 
                }
                af.clear();
                if (!pr.second.empty())
                {
                    break;
                }
                else
                {
                    std::this_thread::yield();
                }
            }
 
            int num = pr.first;
            matrix mtx = pr.second;
            if (mtx.size() > 1)
            {
                for (int j = 0; j < mtx[0].size(); ++j)
                {
                    matrix addMtx = mtx;
                    for (int i = 0; i < addMtx.size(); ++i)
                    {
                        addMtx[i].erase(addMtx[i].begin() + j);
                    }
                    addMtx.erase(addMtx.begin());
 
                    while (af.test_and_set()) {}
                    que.push({ (int)std::pow(-1, 2 + j) * num * mtx[0][j], addMtx });
                    af.clear();
                }
            }
            else if (mtx.size() == 1)
            {
                res += num * mtx.at(0).at(0);
                --goOn;
            }
        }
        
    };
    std::vector<std::thread> vt;
    for (int i = 0; i < 4; ++i)
    {
        vt.emplace_back(lMatrixMinusOneOrder);
    }
    for (auto& t : vt)
    {
        t.join();
    }
    std::cout << "res :" << res << std::endl;
    
}