【问题标题】:std::sort does not always call std::swapstd::sort 并不总是调用 std::swap
【发布时间】:2012-12-22 04:06:23
【问题描述】:

考虑以下代码:

#include <algorithm>
#include <iostream>
#include <vector>

namespace my_space
{

struct A
{
    double  a;
    double* b;
    bool operator<(const A& rhs) const
    {
        return this->a < rhs.a;
    }
};

void swap(A& lhs, A& rhs)
{
    std::cerr << "My swap.\n";
    std::swap(lhs.a, rhs.a);
    std::swap(lhs.b, rhs.b);
}

}

int main()
{
    const int n = 20;
    std::vector<my_space::A> vec(n);
    for (int i = 0; i < n; ++i) {
        vec[i].a = -i;
    }

    for (int i = 0; i < n; ++i) {
        std::cerr << vec[i].a << " ";
    }
    std::cerr << "\n";
    std::sort(vec.begin(), vec.end());
    for (int i = 0; i < n; ++i) {
        std::cerr << vec[i].a << " ";
    }
    std::cerr << "\n";
}

如果我使用n=20,则会调用自定义交换函数并对数组进行排序。但是如果我使用n=4,数组排序正确,但自定义交换函数不被调用。这是为什么?如果复制我的对象真的很昂贵怎么办?

对于这个测试,我使用的是 gcc 4.5.3。

【问题讨论】:

  • This question 应该会有所帮助。
  • 顺便说一句,为什么要使用std::cerr 进行正常输出?
  • 我不使用cerr 进行正常输出。我将cout 用于正常输出,cerr 用于错误消息、诊断和调试。在这种情况下,我想我可以使用cout。
  • +1 这个问题让我进行了大量挖掘,尽管我知道原因的大致轮廓。

标签: c++ stl


【解决方案1】:

对于小范围,出于性能原因,GCC 的 stdlibc++(和其他标准库实现)中的 std::sort 实现会重复插入排序(它比小范围上的快速排序/ introsort 更快)。

反过来,GCC 的插入排序实现不通过 std::swap 进行交换——相反,它一次移动整个范围的值,而不是单独交换,因此可能会节省性能。相关部分在这里(bits/stl_algo.h:2187, GCC 4.7.2):

typename iterator_traits<_RandomAccessIterator>::value_type
  __val = _GLIBCXX_MOVE(*__i);
_GLIBCXX_MOVE_BACKWARD3(__first, __i, __i + 1);
*__first = _GLIBCXX_MOVE(__val);

_GLIBCXX_MOVE 与 C++11 中的 std::move 相同,_GLIBCXX_MOVE_BACKWARD3 是 std::move_backward - 但是,只有在定义了 __GXX_EXPERIMENTAL_CXX0X__ 时才会出现这种情况;如果不是,那么这些操作会使用复制而不是移动!

这样做是将当前位置 (__i) 的值移动到临时存储区,然后将所有先前的值从 __first 移动到 __i,然后将临时值重新插入到 @ 987654334@。因此,这会在一个操作中执行 n 次交换,而不必将 n 值移动到临时位置:

  first           i
+---+---+---+---+---+---+
| b | c | d | e | a | f |
+---+---+---+---+---+---+
                  |
  <---------------+


  first           i
+---+---+---+---+---+---+
| --> b-> c-> d-> e-> f |
+---+---+---+---+---+---+


  first           i
+---+---+---+---+---+---+
| a | b | c | d | e | f |
+---+---+---+---+---+---+
  ^

【讨论】:

  • 因此,如果移动比交换您的类型要昂贵得多,那么 GCC 的策略是悲观的。但优化交换而不是优化移动是“你自己的错”,对吧?
  • @SteveJessop 是的,是的。
  • 谢谢!谢谢你,史蒂夫,在评论中提出了一个很好的问题!
  • 只是为我自己(和其他人)澄清。 “优化move”就是写一个move构造函数吧?
  • @Ben 你真的也想要一个移动任务。
【解决方案2】:

根据类型,交换可能比移动赋值更昂贵(在 C++98 中是简单的赋值)。标准库没有任何方法来检测这些情况。至少在 C++11 中,解决方案很明确:为所有实现交换的类实现移动赋值运算符。

【讨论】:

    【解决方案3】:

    我将代码修改为更详细。 20 个元素的排序使用多次交换,使用赋值结束副本。对 4 个元素进行排序仅使用分配和复制。不知道规格,但它可能会继续。

    #include <algorithm>
    #include <iostream>
    #include <vector>
    
    namespace my_space
    {
    
    struct A
    {
        double  a;
        double* b;
        A()
            : a(0)
            , b(NULL)
        { }
        A(const A &rhs)
            : a(rhs.a)
            , b(rhs.b)
        {
            std::cerr << "copy" << std::endl;
        }
        A& operator=(A const &rhs)
        {
            if(this==&rhs)
                    return *this;
            a = rhs.a;
            b = rhs.b;
            std::cerr << "=" << std::endl;
            return *this;
        }
        bool operator<(const A& rhs) const
        {
            return this->a < rhs.a;
        }
    };
    
    void swap(A& lhs, A& rhs)
    {
        std::cerr << "My swap.\n";
        std::swap(lhs.a, rhs.a);
        std::swap(lhs.b, rhs.b);
    }
    
    } // namespace my_space
    
    int main()
    {
        const int n = 20;
    
            std::cerr << "=== TEST CASE: n = " << n << std::endl;
        std::cerr << "=== FILL ===" << std::endl;
        std::vector<my_space::A> vec(n);
        for (int i = 0; i < n; ++i) {
            vec[i].a = -i;
        }
    
        std::cerr << "=== PRINT ===" << std::endl;
        for (int i = 0; i < n; ++i) {
            std::cerr << vec[i].a << " ";
        }
        std::cerr << "\n";
    
        std::cerr << "=== SORT ===" << std::endl;
        std::sort(vec.begin(), vec.end());
    
        std::cerr << "=== PRINT ===" << std::endl;
        for (int i = 0; i < n; ++i) {
            std::cerr << vec[i].a << " ";
        }
        std::cerr << "\n";
    }
    

    输出

    === TEST CASE: n = 4
    === FILL ===
    copy
    copy
    copy
    copy
    === PRINT ===
    0 -1 -2 -3
    === SORT ===
    copy
    =
    =
    copy
    =
    =
    =
    copy
    =
    =
    =
    =
    === PRINT ===
    -3 -2 -1 0
    

    和

    === TEST CASE: n = 20
    === FILL ===
    copy
    copy
    copy
    copy
    copy
    copy
    copy
    copy
    copy
    copy
    copy
    copy
    copy
    copy
    copy
    copy
    copy
    copy
    copy
    copy
    === PRINT ===
    0 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12 -13 -14 -15 -16 -17 -18 -19
    === SORT ===
    copy
    My swap.
    My swap.
    My swap.
    My swap.
    My swap.
    My swap.
    My swap.
    My swap.
    My swap.
    My swap.
    copy
    copy
    =
    copy
    copy
    =
    copy
    copy
    =
    copy
    copy
    =
    copy
    copy
    =
    copy
    copy
    =
    copy
    copy
    =
    copy
    copy
    =
    copy
    copy
    =
    copy
    copy
    =
    copy
    copy
    =
    copy
    copy
    =
    copy
    copy
    =
    copy
    copy
    =
    copy
    copy
    =
    copy
    =
    copy
    =
    copy
    =
    copy
    =
    === PRINT ===
    -19 -18 -17 -16 -15 -14 -13 -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0
    

    【讨论】:

    • 顺便说一句:SGI 的排序使用en.wikipedia.org/wiki/Introsort,它在某些时候会改变策略。
    • 您可能需要实现堆排序,因此您只能使用交换。对于有效的稳定排序,您将需要副本和/或分配。有一种称为“就地合并排序”的就地稳定排序,它可能只使用交换,但速度有点慢(nlognlogn,而不是 n*logn)。
    • 但是std::sort 不一定要稳定。所以交换与不交换不会影响这里的复杂性。
    • 对于 20 个元素,我自己的堆排序实现使用了 62 次交换,仅此而已。 G++ 的 STL 使用了 99 次操作(35 次复制,19 次赋值,10 次交换,35 次删除)。不要认为它是武器等级!它缺乏许多可用性功能。链接:pastebin.com/5SVm6Tz9
    猜你喜欢
    • 1970-01-01
    • 2020-11-03
    • 1970-01-01
    • 1970-01-01
    • 2021-10-01
    • 1970-01-01
    • 2022-01-05
    • 2021-10-09
    相关资源
    最近更新 更多