std::vector 的高效传递

Question

当 C++ 函数接受 std::vector 参数时，通常的模式是通过 const 引用传递它，例如：

int sum2(const std::vector<int> &v)
{
   int s = 0;
   for(size_t i = 0; i < v.size(); i++) s += fn(v[i]);
   return s;
}

我相信此代码会导致双重解引用访问向量元素，因为CPU应该首先取消引用v来读取指向第一个元素的指针，需要再次取消引用该指针才能读取第一个元素。我希望在堆栈上传递向量对象的浅副本会更有效。这种浅拷贝将封装指向第一个元素的指针和大小，该指针引用与原始向量相同的内存区域。

int sum2(vector_ref<int> v)
{
   int s = 0;
   for(size_t i = 0; i < v.size(); i++) s += fn(v[i]);
   return s;
}

通过传递随机访问迭代器对可以实现类似的性能，但便利性要差得多。 我的问题是：这个想法有什么缺陷？我希望聪明人应该有一些充分的理由接受支付矢量引用的性能成本，或者处理迭代器的不便。

编辑：根据下面的评论，如果我只是将建议的 vector_ref 类重命名为 slice 或 range，请考虑这种情况。目的是使用具有更自然语法的随机访问迭代器对。

Answer 1

我认为访问向量元素时此代码会导致双重解引用

但不一定。编译器非常聪明，应该能够消除常见的子表达式。他们可以看到运算符[] 不会更改“指向第一个元素的指针”，因此不需要让 CPU 在每次循环迭代时从内存中重新加载它。

Answer 2

你的想法的问题在于你已经有了两个完美的解决方案：

• 按原样传递向量，或者通过值（编译器通常会消除副本），或者通过（const）引用，并相信编译器消除双精度间接，或
• 传递迭代器对。

当然，你可以说迭代器对是“不太自然的语法”，但我不同意。对于任何习惯了 STL 的人来说，这都是非常自然的。它非常高效，并且可以使用标准算法或您自己的函数为您提供处理该范围所需的信息。

迭代器对是常见的 C++ 习惯用法，阅读您的代码的 C++ 程序员将毫无问题地理解它们，而他们会对您自制的向量包装器感到惊讶。

如果您对性能确实很偏执，请传递这对迭代器。如果语法确实让您烦恼，请传递向量并信任编译器。

Answer 3

这个想法有什么缺陷？

很简单：这是不成熟的优化。替代方案：接受 vector。 const& 并使用迭代器或将迭代器直接传递给函数。

Answer 4

你是对的，这里有一个额外的间接。如果编译器（在链接时代码生成的帮助下）将其优化掉，这是可以想象的（尽管这会令人惊讶）。

您提出的有时称为切片，并且在某些情况下广泛使用。不过，总的来说，我不确定是否值得冒这样的危险。您必须非常小心地避免使您的切片（或其他人的切片）无效。

请注意，如果您在循环中使用迭代器而不是索引，那么您只需解引用引用几次（调用 begin() 和 end()）比 n 倍（索引到向量中）。

int sum(const vector<int> &v)
{
   int s = 0;
   for (auto it = v.begin(); it != v.end(); ++it) {
       s += fn(*it);
   }
   return s;
}

（我假设优化器会将 end() 调用提升到循环之外。您可以明确地执行此操作以确保确定。）

传递一对迭代器而不是容器本身似乎是 STL成语。这将为您提供更多的通用性，因为容器的类型可能会有所不同，但所需的取消引用的数量也可能会有所不同。

Answer 5

按值传递，除非您确定按引用传递可以提高性能。

当您按值传递时，可能会发生复制省略，这将导致类似的性能（如果不是更好的话）。

戴夫在这里写了相关内容：

http://cpp -next.com/archive/2009/08/want-speed-pass-by-value/

Answer 6

不存在双重解引用，因为编译器可能会将指向向量的实际指针作为参数传递，而不是指向指针的指针。您可以简单地尝试一下，并检查 IDE 的反汇编视图，了解幕后实际发生的情况：

void Method(std::vector<int> const& vec) {
 int i = vec.back();
}


void SomeOtherMethod() {
  std::vector<int> vec;
  vec.push_back(1);
  Method(vec);
}

这里发生了什么？该向量分配在堆栈上。第一个推回被翻译为：

push        eax  // this is the constant one that has been stored in eax
lea         ecx,[ebp-24h] // ecx is the pointer to vec on the stack
call        std::vector<int,std::allocator<int> >::push_back

现在我们调用 Method()，传递向量 const&：

lea         ecx,[ebp-24h] 
push        ecx  
call        Method (8274DC0h) 

毫不奇怪，指向向量的指针被传递，因为引用只不过是永久取消引用的指针。现在在 Method() 内部，再次访问向量：

mov         ecx,dword ptr [ebp+8] 
call        std::vector<int,std::allocator<int> >::back (8276100h)

向量指针直接从堆栈中取出并写入 ecx。