C++ 将文件高效读取到二维阵列

我有两个大文件，一个是

int

，另一个是

float

。我想将它们存储在2d

向量中

读取此类数据的最快方式是什么

注意：每行中的元素数在整个文档中是唯一的

我做了什么

std::string temp;
std::ifstream infile(Path);
int i=0;
std::vector<std::vector<float> data(100, std::vector<float>(1000));
while (std::getline(infile, temp))
    {
        std::istringstream buffer(temp);
        int j = 0;
        while (!buffer.eof())
        {
            float temp2;
            buffer >> temp2;
            if (buffer.fail())
            {
                throw "Undefined variable in the input file!";
            }

                data.at(i).at(j) = temp2;
            j++;
        }
        i++;
    }

std:：字符串温度；
标准：：ifstream infle（路径）；
int i=0；
std:：vector>temp2；
if（buffer.fail（））
{
抛出“输入文件中未定义的变量！”；
}
数据.at（i）.at（j）=temp2；
j++；
}
i++；
}

这个代码非常慢
 如果元素（和行）的数量是唯一的，则不能使用预先确定大小的向量和索引。

如果元素比您想象的多，它不仅会崩溃，而且所有您不替换的元素都将为零（或为空）

相反，从空向量开始，使用
推回


为了避免向量的重新分配，可以先使用
reserve

大概是这样的：

std::string line;
std::ifstream infile(Path);
std::vector<std::vector<float>> data;
data.reserve(100);  // Assuming no more than 100 lines

while (std::getline(infile, line))
{
    data.emplace_back();
    std::vector<float>& row = data.back();
    row.reserve(1000); // Assuming 1000 elements will do
    std::istringstream buffer(line);
    float element = 0;
    while (buffer >> element)
    {
        row.push_back(element);
    }
}

std:：字符串行；
标准：：ifstream infle（路径）；
std：：矢量数据；
数据保留（100）；//假设不超过100行
while（std:：getline（infle，line））
{
data.emplace_back（）；
std:：vector&row=data.back（）；
row.reserve（1000）；//假设1000个元素就可以了
std:：istringstream缓冲区（行）；
浮动元素=0；
while（缓冲区>>元素）
{
行。推回（元素）；
}
}

如果您希望尽可能快地阅读，请不要对数据使用文本格式
 如果元素（和行）的数量是唯一的，则不能使用预先确定大小的向量和索引。

如果元素比您想象的多，它不仅会崩溃，而且所有您不替换的元素都将为零（或为空）

相反，从空向量开始，使用
推回


为了避免向量的重新分配，可以先使用
reserve

大概是这样的：

std::string line;
std::ifstream infile(Path);
std::vector<std::vector<float>> data;
data.reserve(100);  // Assuming no more than 100 lines

while (std::getline(infile, line))
{
    data.emplace_back();
    std::vector<float>& row = data.back();
    row.reserve(1000); // Assuming 1000 elements will do
    std::istringstream buffer(line);
    float element = 0;
    while (buffer >> element)
    {
        row.push_back(element);
    }
}

std:：字符串行；
标准：：ifstream infle（路径）；
std：：矢量数据；
数据保留（100）；//假设不超过100行
while（std:：getline（infle，line））
{
data.emplace_back（）；
std:：vector&row=data.back（）；
row.reserve（1000）；//假设1000个元素就可以了
std:：istringstream缓冲区（行）；
浮动元素=0；
while（缓冲区>>元素）
{
行。推回（元素）；
}
}

如果您希望尽可能快地阅读，请不要对数据使用文本格式
 如果元素（和行）的数量是唯一的，则不能使用预先确定大小的向量和索引。

如果元素比您想象的多，它不仅会崩溃，而且所有您不替换的元素都将为零（或为空）

相反，从空向量开始，使用
推回


为了避免向量的重新分配，可以先使用
reserve

大概是这样的：

std::string line;
std::ifstream infile(Path);
std::vector<std::vector<float>> data;
data.reserve(100);  // Assuming no more than 100 lines

while (std::getline(infile, line))
{
    data.emplace_back();
    std::vector<float>& row = data.back();
    row.reserve(1000); // Assuming 1000 elements will do
    std::istringstream buffer(line);
    float element = 0;
    while (buffer >> element)
    {
        row.push_back(element);
    }
}

std:：字符串行；
标准：：ifstream infle（路径）；
std：：矢量数据；
数据保留（100）；//假设不超过100行
while（std:：getline（infle，line））
{
data.emplace_back（）；
std:：vector&row=data.back（）；
row.reserve（1000）；//假设1000个元素就可以了
std:：istringstream缓冲区（行）；
浮动元素=0；
while（缓冲区>>元素）
{
行。推回（元素）；
}
}

如果您希望尽可能快地阅读，请不要对数据使用文本格式
 如果元素（和行）的数量是唯一的，则不能使用预先确定大小的向量和索引。

如果元素比您想象的多，它不仅会崩溃，而且所有您不替换的元素都将为零（或为空）

相反，从空向量开始，使用
推回


为了避免向量的重新分配，可以先使用
reserve

大概是这样的：

std::string line;
std::ifstream infile(Path);
std::vector<std::vector<float>> data;
data.reserve(100);  // Assuming no more than 100 lines

while (std::getline(infile, line))
{
    data.emplace_back();
    std::vector<float>& row = data.back();
    row.reserve(1000); // Assuming 1000 elements will do
    std::istringstream buffer(line);
    float element = 0;
    while (buffer >> element)
    {
        row.push_back(element);
    }
}

std:：字符串行；
标准：：ifstream infle（路径）；
std：：矢量数据；
数据保留（100）；//假设不超过100行
while（std:：getline（infle，line））
{
data.emplace_back（）；
std:：vector&row=data.back（）；
row.reserve（1000）；//假设1000个元素就可以了
std:：istringstream缓冲区（行）；
浮动元素=0；
while（缓冲区>>元素）
{
行。推回（元素）；
}
}

如果您希望尽可能快地阅读，请不要对数据使用文本格式
 没有什么提示

通过添加以下内容禁用stdio同步：

std::ios::sync_with_stdio(false);


在代码的顶部

重新使用std:：istringstream，放置：

std::istringstream buffer(temp);


在循环之外，使用它之后，用
buffer.clear（）清除它

而不是：

data.at(i).at(j) = temp2;


使用：

此版本不检查边界，因此速度稍快。
很少提示

通过添加以下内容禁用stdio同步：

std::ios::sync_with_stdio(false);


在代码的顶部

重新使用std:：istringstream，放置：

std::istringstream buffer(temp);


在循环之外，使用它之后，用
buffer.clear（）清除它

而不是：

data.at(i).at(j) = temp2;


使用：

此版本不检查边界，因此速度稍快。
很少提示

通过添加以下内容禁用stdio同步：

std::ios::sync_with_stdio(false);


在代码的顶部

重新使用std:：istringstream，放置：

std::istringstream buffer(temp);


在循环之外，使用它之后，用
buffer.clear（）清除它

而不是：

data.at(i).at(j) = temp2;


使用：

此版本不检查边界，因此速度稍快。
很少提示

通过添加以下内容禁用stdio同步：

std::ios::sync_with_stdio(false);


在代码的顶部

重新使用std:：istringstream，放置：

std::istringstream buffer(temp);


在循环之外，使用它之后，用
buffer.clear（）清除它

而不是：

data.at(i).at(j) = temp2;


使用：

此版本不检查边界，因此速度稍快。
您的代码是否正常工作？您正在索引
数据
，但我看不到您在任何地方都设置了它的大小data（100，std:：vector（1000））。添加。您仍然缺少
i
的声明和初始化。您的代码是否正常工作？你正在索引