递增迭代器：“它比它更高效吗”？

发布于 2024-07-25 15:06:43 字数 613 浏览 2 评论 0原文

可能的重复：
i++ 和 ++ 之间是否存在性能差异我在 C++ 中？

我正在编写一个程序，其中使用迭代器循环遍历 std::vector。有人告诉我，在 for 语句中执行 ++it 可以提高代码效率。换句话说，他们是在说：

for ( vector<string>::iterator it=my_vector.begin(); it != my_vector.end(); ++it )

跑得比别人快

for ( vector<string>::iterator it=my_vector.begin(); it != my_vector.end(); it++ )

这是真的吗？如果是，效率提升的原因是什么？它 ++/++ 所做的只是将迭代器移动到向量中的下一项，不是吗？

原文

Possible Duplicate:
Is there a performance difference between i++ and ++i in C++?

I am writing a program where an iterator is used to loop through a std::vector. Somebody told me that doing ++it in the for statement leads to more efficient code. In other words, they are saying that:

for ( vector<string>::iterator it=my_vector.begin(); it != my_vector.end(); ++it )

runs faster than

for ( vector<string>::iterator it=my_vector.begin(); it != my_vector.end(); it++ )

Is this true? If it is, what is the reason behind the efficiency improvement? All it++/++it does is move the iterator to the next item in the vector, isn't it?

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

匿名。 2024-08-01 15:06:44

it++ 有可能创建一个临时副本。

另外，在 C++ 中，有人可能会重载后递增运算符。

与预增量相比，这两件事都可能会降低性能。在实践中，这两者都不重要。尤其是临时副本，将被大多数编译器优化掉，因为 For 循环的第三个表达式没有副作用。

回复收藏 0 原文

情深已缘浅 2024-08-01 15:06:44

是的 ++ 它更高效，因为它 ++ 需要返回对象的副本然后递增自身。

回复收藏 0 原文

溇涏 2024-08-01 15:06:44

是的。据我记得，++it比it++更高效，因为it++创建了一个临时对象，而++it则没有。

回复收藏 0 原文

甜是你 2024-08-01 15:06:43

预增量更快的原因是后增量必须复制旧值才能返回。正如 GotW #2 所说，“预增量比后增量更有效，因为对于后增量对象必须递增自身，然后返回一个包含其旧值的临时值，即使对于 int 这样的内置函数也是如此。”

GotW #55 提供了后增量的规范形式，这表明它必须执行前增量加上还有更多工作：

T T::operator++(int)
{
  T old( *this ); // remember our original value
  ++*this;        // always implement postincrement
                  //  in terms of preincrement
  return old;     // return our original value
}

正如其他人所指出的，某些编译器在某些情况下可能会对此进行优化，但如果您不使用返回值，那么最好不要依赖此优化。此外，对于具有简单复制构造函数的类型，性能差异可能非常小，尽管我认为在 C++ 中使用预自增是一个好习惯。

The reason behind the preincrement being faster is that post-increment has to make a copy of the old value to return. As GotW #2 put it, "Preincrement is more efficient than postincrement, because for postincrement the object must increment itself and then return a temporary containing its old value. Note that this is true even for builtins like int."

GotW #55 provides the canonical form of postincrement, which shows that it has to do preincrement plus some more work:

T T::operator++(int)
{
  T old( *this ); // remember our original value
  ++*this;        // always implement postincrement
                  //  in terms of preincrement
  return old;     // return our original value
}

As others have noted, it's possible for some compiler to optimize this away in some cases, but if you're not using the return value it's a good idea not to rely on this optimization. Also, the performance difference is likely to be very small for types which have trivial copy constructors, though I think using preincrement is a good habit in C++.

回复收藏 0 原文