C++ c++；getline文件复制到字符串时输出更改

我有一个文件，它的每一行都有一行矩阵，在每一行中，两个数字之间有空格，这个文件包括很多矩阵，它们之间有一个空行

现在我有两种不同版本的代码：

1-使用getline（file，readLine）从文件中读取单线程，并直接处理readLine，将其拆分，然后使用stod生成双数并生成矩阵

#include <fstream>
#include <string>

using namespace std;

void decomposeSerial(double *A, long n)
{
    long i, j, k;
    for (k = 0; k < n; k++) {
        for (j = k + 1; j < n; j++)
            A[k*n + j] = A[k*n + j] / A[k*n + k];

        for (i = k + 1; i < n; i++)
            for (j = k + 1; j < n; j++)
                A[i*n + j] = A[i*n + j] - A[i*n + k] * A[k*n + j];
    }
}

void main() {
    const string inFilePath = ".\\data_in\\file.txt";
    const string outFilePath = ".\\data_out\\file.txt";
    ifstream inFile(inFilePath);
    ofstream outFile(outFilePath);
    int n;
    int matrixLine = 0;
    double * matrix = NULL;
    string readLine;
    while (getline(inFile, readLine)) {
        if (!readLine.empty()) {
            if (matrixLine == 0) {
                n = 0;
                string temp = readLine;
                size_t pos = 0;
                while ((pos = temp.find(" ")) != string::npos) {
                    temp.erase(0, pos + 1);
                    n++;
                }
                matrix = (double *)malloc(sizeof(double) * n * n);
            }
            size_t pos = 0;
            string token;
            int i = 0;
            while ((pos = readLine.find(" ")) != string::npos) {
                token = readLine.substr(0, pos);
                matrix[matrixLine * n + i] = stod(token);
                readLine.erase(0, pos + 1);
                i++;
            }
            matrixLine++;
            if (matrixLine == n) {
                decomposeSerial(matrix, n);
                double det = 1;
                for (long o = 0; o < n; o++) {
                    det *= matrix[o * n + o];
                }
                outFile << det << "\n";
            }
        }
        else {
            matrixLine = 0;
        }
    }
    inFile.close();
    outFile.close();
}

#include <fstream>
#include <string>
#include <omp.h>

using namespace std;

double det[1000];
string input[1000];
int ns[1000];

void computation(double* src, int n, int l)
{
    long i, j, k;
    for (k = 0; k < n; k++) {
        for (j = k + 1; j < n; j++)
            src[k*n + j] = src[k*n + j] / src[k*n + k];

        for (i = k + 1; i < n; i++)
            for (j = k + 1; j < n; j++)
                src[i*n + j] = src[i*n + j] - src[i*n + k] * src[k*n + j];
    }
    double res = 1;
    for (int j = 0; j < n; j++) {
        res *= src[j*n + j];
    }
    det[l] = res;
}

void main() {
    const string inFilePath = ".\\data_in\\file.txt";
    const string outFilePath = ".\\data_out\\file.txt";
    ifstream inFile(inFilePath);
    int matrixCount = 0;
    bool inMatrix = false;
    string readLine;
    int dim = 0;
    while (getline(inFile, readLine)) {
        dim++;
        if (readLine.empty()) {
            ns[matrixCount] = dim - 1;
            dim = 0;
            inMatrix = false;
            matrixCount++;
        }
        else {
            if (inMatrix == false) {
                inMatrix = true;
                input[matrixCount] = readLine;
            }
            else {
                input[matrixCount] += readLine;
            }
        }
    }
    ns[matrixCount] = dim;
    matrixCount++;
    inFile.close();
#pragma omp parallel
    {
#pragma omp for schedule(dynamic)
        for (int i = 0; i < matrixCount; i++) {
            string matrixStr = input[i];
            int n = ns[i];
            double * matrix = (double *)malloc(sizeof(double) * n * n);
            size_t pos = 0;
            string token;
            int k = 0;
            while ((pos = matrixStr.find(" ")) != string::npos) {
                token = matrixStr.substr(0, pos);
                matrix[k] = stod(token);
                matrixStr.erase(0, pos + 1);
                k++;
            }
            computation(matrix, n, i);

            free(matrix);
        }
    }
    ofstream outFile(outFilePath);
    for (int i = 0; i < matrixCount; i++) {
        outFile << det[i] << "\n";
    }
    outFile.close();
}

#包括
#包括
使用名称空间std；
空分解序列（双*A，长n）
{
长i，j，k；
对于（k=0；koutFile这些性能问题是无法解释的。您需要使用探查器并测量代码的哪些部分占用了多少时间

首先，我将使两个代码更加相似。有很多差异可能会混淆问题（因为版本1有一次出现了巨大的内存泄漏）。
这些性能问题无法解释。您需要使用探查器并测量代码的哪些部分占用了多少时间

首先，我会使两个代码更加相似。有很多差异可能会混淆问题（因为版本1有一次出现了巨大的内存泄漏）。
如果没有看到至少一些代码，几乎不可能回答。假设
readLine
是
std:：string
，
printf（“%s”，readLine）
表现出未定义的行为。首先，
%s
说明符要求对应的参数为
char*
，其次，非POD类（如
std:：string
）不能传递给变量函数（如
printf
）@ IgorTandetnik，抱歉坏C++知识，我在这方面没有太多的EXP，但是我用PrimTf来测试，问题是在某个地方编辑了这个问题，这样代码就可以直接看到，而不必跟随一个链接。在将来，你尝试为你发布的问题/答案做一次。而且，你说一个版本要慢得多。你有多慢？测量此值？请将其添加到问题中。如果没有看到至少一些代码，几乎不可能回答。假设
readLine
是
std:：string
，
printf（“%s”，readLine）
表现出未定义的行为。首先，
%s
说明符要求对应的参数为
char*
，其次，非POD类（如
std:：string
）不能传递给变量函数（如
printf
）@ IgorTandetnik，抱歉坏C++知识，我在这方面没有太多的EXP，但是我用PrimTf来测试，问题是在某个地方编辑了这个问题，这样代码就可以直接看到，而不必跟随一个链接。在将来，你尝试为你发布的问题/答案做一次。而且，你说一个版本要慢得多。你有多慢？测量这个？请将它添加到问题中。唯一的巨大区别是可以注释的#pragma，它仍然是一样的，关于内存泄漏，是的，我不知道这个lang的垃圾收集器，但由于问题与此相反，我应该填写一份考虑到这些代码的报告，我宁愿不改变唯一的巨大区别ence是可以评论的，关于内存泄漏，它仍然是一样的，是的，我不知道这个语言的垃圾收集器，但问题与此相反，我应该填写一份考虑到这些代码的报告，我宁愿不更改