Question

ı想用线程计算矩阵的行列式，但我有一个错误“术语不会影响一个带0参数的函数”ı想用线程和解析矩阵求解大矩阵，什么可以做什么

int determinant(int f[1000][1000], int x)
    {
        int pr, c[1000], d = 0, b[1000][1000], j, p, q, t;
        if (x == 2)
        {
            d = 0;
            d = (f[1][1] * f[2][2]) - (f[1][2] * f[2][1]);
            return(d);
        }
        else
        {
            for (j = 1; j <= x; j++)
            {
                int r = 1, s = 1;
                for (p = 1; p <= x; p++)
                {
                    for (q = 1; q <= x; q++)
                    {
                        if (p != 1 && q != j)
                        {
                            b[r][s] = f[p][q];
                            s++;
                            if (s > x - 1)
                            {
                                r++;
                                s = 1;
                            }
                        }
                    }
                }
                for (t = 1, pr = 1; t <= (1 + j); t++)
                    pr = (-1)*pr;
                c[j] = pr*determinant(b, x - 1);
            }
            for (j = 1, d = 0; j <= x; j++)
            {
                d = d + (f[1][j] * c[j]);
            }
            return(d);
        }
    }

    int main()
    {
        srand(time_t(NULL));
        int i, j;
        printf("\n\nEnter order of matrix : ");
        scanf_s("%d", &m);
        printf("\nEnter the elements of matrix\n");
        for (i = 1; i <= m; i++)
        {
            for (j = 1; j <= m; j++)
            {
                a[i][j] = rand() % 10;
            }
        }
        thread t(determinant(a, m));
        t.join();
        printf("\n Determinant of Matrix A is %d .", determinant(a, m));

    }

Answer 1

当前问题是：thread t(determinant(a, m));您将调用determinant(a, m)的结果作为要执行的函数传递，并使用零参数调用该函数 - 但是int不是函数或其他可调用对象，这就是你所抱怨的错误。

std::thread的{{3}}需要运行函数和单独提供的参数，因此您需要调用std::thread(determinant, a, m)。

现在我们遇到了另一个问题，std::thread没有提供检索返回值的方法，所以你再次计算：printf("\n Determinant of Matrix A is %d .", determinant(a, m));。

要解决此问题，我们可以使用<future>标头中的constructor来管理我们的线程处理，并让我们稍后检索结果：

auto result = std::async(std::launch::async, determinant, a, m);
int det = result.get()

这将在新线程上运行determinant(a,m)，并返回最终可能放置返回值的std::future<int>。然后我们可以尝试使用std::future::get()检索该值，该值将一直阻塞，直到可以检索到该值（或直到线程中发生异常）。

在这个例子中，我们仍然以非常串行的方式执行determinant，因为我们将工作委托给一个线程，然后在继续之前等待该线程完成其工作。但是，我们现在可以自由地存储future，并推迟调用std::future::get()，直到我们确实需要该值，可能在您的程序中稍晚。

其余代码还有一些其他问题：

所有数组索引都是一个（数组索引在C和C ++中从0运行到N-1）
您使用的一些变量不存在（例如a和m）
C数组是通过指针传递的，所以如果你改变代码不要在那里的线程上阻塞，那么数组将超出范围，你的线程可能会从悬空指针中读取垃圾。如果您使用适当的容器（如std::array或std::vector），则可以按值传递，以便您的线程拥有数据以便在其整个生命周期内运行。

用线程计算矩阵的行列式

1 个答案: