C++ 将一个STL向量有效分配给另一个STL向量（WSL问题）

我有一个关于STL向量赋值时间的问题

上下文是：我正在将二进制文件读入

std:：vector

中，如下所示：

std::vector<float> read_file(const std::string &file_path) {

    std::ifstream stream(file_path);

    if (!stream.good()) {
        std::cout << "Cannot open file located at: " << file_path << std::endl;
        return std::vector<float>();
    }

    stream.seekg(0, std::ios_base::end);    
    auto size = stream.tellg();
    stream.seekg(0, std::ios_base::beg);

    std::vector<float> values(size / sizeof(float));
    stream.read((char*) &values[0], size);

    stream.close();

    return values;
}

std:：vector读取文件（const std:：string和文件路径）{
std:：ifstream流（文件路径）；
如果（！stream.good（））{
std：：cout这不是一个答案，这是一种试图理解时间差异的方法，但这太长了，不能作为备注给出

在第一种情况下，您总是重用内存中的相同块，执行期间所需的大小很小

但在第二种解决方案中，您需要128倍的内存，这可能是时间差异的原因吗？如果执行时间是实时的（执行期间交换），那么这是强制执行的

要比较这些案例：

int main(int, char ** argv)
{
  switch (*argv[1]) {
  case '1':
    {
      // this is your first case
      std::vector<float> data;
      for (int i = 1; i <= 128; ++i) {
        data = read_file(getFile(i));
      }
    }
    break;
  case '2':
    {
      // this is your seconde case
      std::vector<std::vector<float>> data(128);
      for (auto i = 1; i <= 128; ++i) {
        data[i-1] = read_file(getFile(i));
      }
    }
    break;
  default:
    {
      // this is equivalent to your first case EXCEPT that needs 128 times more memory 
      std::vector<std::vector<float> *> data(128);
      for (auto i = 1; i <= 128; ++i) {
        data[i-1] = new std::vector<float>();
        *(data[i-1]) = read_file(getFile(i));
      }
    }
    break;
  }

  return 0;
}

int main（int，char**argv）
{
开关（*argv[1]）{
案例“1”：
{
//这是你的第一个病例
std：：矢量数据；
对于（int i=1；i我发现的问题是WSL环境（我正在通过它编译，使用CLion）的i/O性能很低。尽管我在问题中没有提到这一点，但我必须在不同的平台和系统上编译相同的程序，以了解到底发生了什么

设置另一个建筑环境修复了该问题（执行时间现在与示例1和示例2非常相似）
提供一个包装类，它允许您查看对一维向量的引用，并通过整数索引执行访问行和列的计算。因此，您根本不需要复制任何内容。@UlrichEckhardt好的，我有点理解。（但我想展示真正的代码，因为我真的用这个函数来处理<代码> int /代码>值）。这对我来说是完全好的。然而，当准备你的问题在这里发布时，最好的做法是剥离不必要的部分，以避免你甚至没有考虑过的代码的杂乱无章的影响。BTW：如果你在改进性能之后，考虑一个提供只读视图并在后台使用内存映射的容器。如果你做了“代码> STD：：矢量数据；DATA。保留（128）；，然后推回矢量，而不是<代码> STD:：矢量数据（128），你可以节省一些动态分配。
。您是如何测试执行时间的？时间差可能是由操作系统缓存文件造成的。这将导致第二次运行的时间大大缩短。我建议改用探查器，这样您可以看到代码的哪一部分实际上减慢了操作。2和3之间的时间是相似的。不过，这非常有趣至少已分配128个向量（读取文件时）-不应该只是地址交换吗？@Shmwel在第一个解决方案中，这并不是因为您读取了128个文件，所有文件都保留在堆中。在解决方案2和3中，所有读取的文件内容都保留在堆中，而不是在第一种情况下，您可能暂时在堆中有2个文件内容
std::vector<std::vector<float>> data(128);
for (auto i = 1; i <= 128; ++i) {
    data[i-1] = read_file(getFile(i));
}

int main(int, char ** argv)
{
  switch (*argv[1]) {
  case '1':
    {
      // this is your first case
      std::vector<float> data;
      for (int i = 1; i <= 128; ++i) {
        data = read_file(getFile(i));
      }
    }
    break;
  case '2':
    {
      // this is your seconde case
      std::vector<std::vector<float>> data(128);
      for (auto i = 1; i <= 128; ++i) {
        data[i-1] = read_file(getFile(i));
      }
    }
    break;
  default:
    {
      // this is equivalent to your first case EXCEPT that needs 128 times more memory 
      std::vector<std::vector<float> *> data(128);
      for (auto i = 1; i <= 128; ++i) {
        data[i-1] = new std::vector<float>();
        *(data[i-1]) = read_file(getFile(i));
      }
    }
    break;
  }

  return 0;
}