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);
    }
}

但是，只有在你需要写三巨头时才这样做（你是{{3}}）。

你不是，所以我不明白这一点。（你的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会在引擎盖下发挥严重作用。

加号 - 你确定双倍，双重算大吗？

矢量排序：交换过载

3 个答案: