比较运算符的速度

发布于 2024-11-16 06:01:51 字数 206 浏览 5 评论 0原文

在诸如...以及任何语言之类的语言中，两个运算符都适用于 <和 <= （及其相反）存在。哪个会更快，它们是如何解释的？

if (x <= y) { 废话； }

或者

if (x < y + 1) { 废话； }

原文

分享到QQ

分享到微博

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

发布评论

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

对岸观火 2024-11-23 06:01:51

假设没有编译器优化（大假设），第一个会更快，因为 <= 是由单个 jle 指令实现的，而后者需要加法后跟 jl指令。

http://en.wikibooks.org/wiki/X86_Assembly/Control_Flow#Jump_if_Less

回复收藏 0 原文

秋日私语 2024-11-23 06:01:51

就性能而言，我根本不担心这个。以 C 为例，在一个简单的测试中，我使用面向 x86 的 GCC 4.5.1（使用 -O2）运行，(x <=y ) 操作编译为:

    // if (x <= y) {
    //     printf( "x <= y\n");
    // }
    //
    // `x` is [esp+28]
    // `y` is [esp+24]

    mov eax, DWORD PTR [esp+24]     // load `y` into eax 
    cmp DWORD PTR [esp+28], eax     // compare with `x`
    jle L5                          // if x < y, jump to the `true` block
L2:

    // ...

    ret

L5: // this prints "x <= y\n"
    mov DWORD PTR [esp], OFFSET FLAT:LC1
    call    _puts
    jmp L2      // jumps back to the code after the ` if statement

和 (x < y + 1) 操作编译为：

    // if (x < y +1) {
    //     printf( "x < y+1\n");
    // }
    //
    // `x` is [esp+28]
    // `y` is [esp+24]

    mov eax, DWORD PTR [esp+28]     // load x into eax
    cmp DWORD PTR [esp+24], eax     // compare with y
    jl  L3                          //  jump past the true block if (y < x)
    mov DWORD PTR [esp], OFFSET FLAT:LC2
    call    _puts
L3:

因此，您可能会在跳跃左右有一个跳跃的差异，但您实际上应该只关心这种事情奇怪的一次，这确实是一个热点。当然，语言之间可能存在差异，具体发生的情况可能取决于正在比较的对象的类型。但就性能而言，我仍然根本不担心这一点（直到它成为一个已证明的性能问题 - 如果它在我的一生中出现超过一两次，我会感到惊讶）。

因此，我认为担心使用哪个测试的唯一两个原因是：

正确性 - 当然，这胜过任何其他考虑
样式/可读性

虽然您可能不认为样式/可读性考虑有很多，我确实有点担心这个。在今天的 C 和 C++ 代码中，我更喜欢使用 < 运算符而不是 <=，因为我认为循环倾向于使用 来“更好”地终止< 比 <= 测试。因此，例如：

按索引迭代数组，通常应该使用 index index index index index index index index index index index index number_of_elements 测试
使用指向元素的指针迭代数组应该使用 ptr (array + number_of_elements) 测试

实际上，即使在 C 语言中，我现在也倾向于使用 ptr != (array + number_of_elements) 因为我已经习惯了 STL 迭代器，其中 <关系赢得了工作。

事实上，如果我在 for 循环条件中看到 <= 测试，我会仔细查看 - 通常存在潜伏的错误。我认为这是一种反模式。

不，我承认其中很多内容可能不适用于其他语言，但如果我使用另一种语言时我必须担心性能问题，我会感到惊讶，因为我选择使用 <= 之上的 <。

I wouldn't worry about this at all as far as performance goes. Using C as an example, on a simple test I ran with GCC 4.5.1 targeting x86 (with -O2), the (x <=y ) operation compiled to:

    // if (x <= y) {
    //     printf( "x <= y\n");
    // }
    //
    // `x` is [esp+28]
    // `y` is [esp+24]

    mov eax, DWORD PTR [esp+24]     // load `y` into eax 
    cmp DWORD PTR [esp+28], eax     // compare with `x`
    jle L5                          // if x < y, jump to the `true` block
L2:

    // ...

    ret

L5: // this prints "x <= y\n"
    mov DWORD PTR [esp], OFFSET FLAT:LC1
    call    _puts
    jmp L2      // jumps back to the code after the ` if statement

and the (x < y + 1) operation compiled to:

    // if (x < y +1) {
    //     printf( "x < y+1\n");
    // }
    //
    // `x` is [esp+28]
    // `y` is [esp+24]

    mov eax, DWORD PTR [esp+28]     // load x into eax
    cmp DWORD PTR [esp+24], eax     // compare with y
    jl  L3                          //  jump past the true block if (y < x)
    mov DWORD PTR [esp], OFFSET FLAT:LC2
    call    _puts
L3:

So you might have a difference of a jump around a jump or so, but you should really only be concerned about this kind of thing for the odd time where it really is a hot spot. Of course there may be differences between languages and what exactly happens might depend on the type of objects that are being compared. But I'd still not worry about this at all as far as performance is concerned (until it became a demonstrated performance issue - which I'll be surprised if it ever does for more than once or twice in my lifetime).

So, I think the only two reasons to worry about which test to use are:

correctness - of course, this trumps any other consideration
style/readabilty

While you might not think there's much to the style/readability consideration, I do worry about this a little. In my C and C++ code today, I'd favor using the < operator over <= because I think loops tend to terminate 'better' using a < than a <= test. So, for example:

iterating over an array by index, you should typically use an index < number_of_elements test
iterating over an array using pointers to elements should use a ptr < (array + number_of_elements) test

Actually even in C, I now tend to use a ptr != (array + number_of_elements) since I've gotten used to STL iterators where the < relation won work.

In fact, if I see a <= test in a for loop condition, I take a close look - often there's a bug lurking. I consider it an anti-pattern.

Noe I'll grant that a lot of this may not hold for other languages, but I be surprised if when I'm using another language that there's ever a performance issues I'll have to worry about because I chose to use < over <=.

回复收藏 0 原文