向量排序：交换过载

Question

我想重载原始类型/对象的 std::vector 的交换函数。原因是使用 std::sort 对包含大对象的向量进行排序很慢。这是一个简单但不起作用的示例。

#include <vector>
#include <algorithm>
class Point
{
private:
    double x, y;
public:
    Point(double xx, double yy) : x(xx), y(yy) {}

    bool operator < ( const Point& p ) const
    {
        return x < p.x;
    }

    void swap(Point &p)
    {
        std::swap(*this, p);
    }

};

namespace std
{
void swap( Point &p1, Point &p2)
{
    p1.swap(p2);
}
}

typedef  std::vector<Point> TPoints;
int main()
{
Point p1(0,0);
Point p2(7,100);

TPoints points;
points.push_back(p1);
points.push_back(p2);

    //Overloaded metod swap will not be called
std::sort(points.begin(), points.end());
}

不幸的是，在 std::sort 期间，没有调用重载方法。我想包含对象的向量也会出现类似的情况...感谢您的帮助...

Answer 1

实现交换的正确方法是：

class foo
{
public:
    void swap(foo& pOther)
    {
        using std::swap; // enable ADL
        swap(member1, pOther.member1); // for all members
    }
};

// allows swap to be found with ADL (place in same namespace as foo)
void swap(foo& pFirst, foo& pSecond)
{
    pFirst.swap(pSecond);
}

// allows swap to be found within std
namespace std
{
    // only specializations are allowed to
    // be injected into the namespace std
    template <>
    void swap(foo& pFirst, foo& pSecond)
    {
        pFirst.swap(pSecond);
    }
}

但是，只有当您需要编写三巨头时才有意义（您是管理某些资源）。

你不是，所以我不明白这一点。 （所有 swap 所做的就是复制一些双精度数，就像默认的 std::swap 一样。）

Answer 2

您必须专门化 std::swap 模板，而不是重载它。

例子：

namespace std
{
    template<>
    void swap<Point>( Point &p1, Point &p2)
    {
        p1.swap(p2);
    }
}

Answer 3

sort可能调用了vector的swap成员函数。无论如何，你不能做你正在做的事情，重新定义 std::swap 会在幕后造成严重破坏。

另外 - 你确定 double, double 算大吗？