如何重载 std::swap()

Question

std::swap() 被许多 std 容器（例如 std::list 和 std::vector）在排序甚至排序过程中使用任务。

但是 swap() 的 std 实现非常通用，对于自定义类型来说效率相当低。

因此，可以通过使用自定义类型特定实现重载 std::swap() 来提高效率。 但是如何实现它以便 std 容器使用它呢？

Answer 1

虽然人们通常不应向 std:: 命名空间添加内容是正确的，但特别允许为用户定义类型添加模板专业化。 函数重载则不然。 这是一个微妙的区别:-)

17.4.3.1/1
C++程序添加声明或定义是未定义的
到命名空间 std 或带有命名空间 std 的命名空间，除非另有说明
指定的。 程序可以为任何添加模板专业化
标准库模板到命名空间 std。 这样的专业
（完整或部分）标准库导致未定义
行为，除非声明依赖于用户定义的名称
外部链接，除非模板专业化满足
原始模板的标准库要求。

std::swap 的特化如下所示：

namespace std
{
    template<>
    void swap(myspace::mytype& a, myspace::mytype& b) { ... }
}

没有模板<> 位，这将是一个未定义的重载，而不是允许的特化。 @Wilka 建议的更改默认名称空间的方法可能适用于用户代码（由于 Koenig 查找更喜欢无名称空间版本），但不能保证，而且实际上并不应该这样做（STL 实现应该使用完全- 合格的 std::swap)。

有一个comp.lang.c++.moderated< /a> 对主题进行长讨论。 不过，其中大部分都是关于部分专业化（目前没有好的方法可以做到）。

Answer 2

重载 std::swap 的实现（也称为专门化它）的正确方法是将其编写在与要交换的内容相同的命名空间中，以便可以通过 参数相关查找 (ADL)。 一件特别容易做的事情是：

class X
{
    // ...
    friend void swap(X& a, X& b)
    {
        using std::swap; // bring in swap for built-in types

        swap(a.base1, b.base1);
        swap(a.base2, b.base2);
        // ...
        swap(a.member1, b.member1);
        swap(a.member2, b.member2);
        // ...
    }
};

Answer 3

注意 Mozza314

这是调用 std::swap 并让用户提供交换的通用 std::algorithm 效果的模拟在命名空间标准中。 由于这是一个实验，因此该模拟使用 namespace exp 而不是 namespace std。

// simulate <algorithm>

#include <cstdio>

namespace exp
{

    template <class T>
    void
    swap(T& x, T& y)
    {
        printf("generic exp::swap\n");
        T tmp = x;
        x = y;
        y = tmp;
    }

    template <class T>
    void algorithm(T* begin, T* end)
    {
        if (end-begin >= 2)
            exp::swap(begin[0], begin[1]);
    }

}

// simulate user code which includes <algorithm>

struct A
{
};

namespace exp
{
    void swap(A&, A&)
    {
        printf("exp::swap(A, A)\n");
    }

}

// exercise simulation

int main()
{
    A a[2];
    exp::algorithm(a, a+2);
}

对我来说，这会打印出来：

generic exp::swap

如果您的编译器打印出不同的内容，那么它就没有正确实现模板的“两阶段查找”。

如果您的编译器符合（符合 C++98/03/11 中的任何一个），那么它将给出与我显示的相同的输出。 在这种情况下，你担心会发生的事情确实会发生。 将您的 swap 放入命名空间 std (exp) 并不能阻止它的发生。

戴夫和我都是委员会成员，十年来一直致力于该标准领域（但彼此的意见并不总是一致）。 但这个问题已经解决了很长时间，我们双方都同意如何解决。 忽视戴夫在该领域的专家意见/答案，后果自负。

这个问题是在 C++98 发布后才暴露出来的。 大约从 2001 年开始，Dave 和我开始在这个领域工作。 这是现代的解决方案：

// simulate <algorithm>

#include <cstdio>

namespace exp
{

    template <class T>
    void
    swap(T& x, T& y)
    {
        printf("generic exp::swap\n");
        T tmp = x;
        x = y;
        y = tmp;
    }

    template <class T>
    void algorithm(T* begin, T* end)
    {
        if (end-begin >= 2)
            swap(begin[0], begin[1]);
    }

}

// simulate user code which includes <algorithm>

struct A
{
};

void swap(A&, A&)
{
    printf("swap(A, A)\n");
}

// exercise simulation

int main()
{
    A a[2];
    exp::algorithm(a, a+2);
}

输出是：

swap(A, A)

更新

观察结果表明：

namespace exp
{    
    template <>
    void swap(A&, A&)
    {
        printf("exp::swap(A, A)\n");
    }

}

有效！ 那么为什么不使用它呢？

考虑一下您的 A 是一个类模板的情况：

// simulate user code which includes <algorithm>

template <class T>
struct A
{
};

namespace exp
{

    template <class T>
    void swap(A<T>&, A<T>&)
    {
        printf("exp::swap(A, A)\n");
    }

}

// exercise simulation

int main()
{
    A<int> a[2];
    exp::algorithm(a, a+2);
}

现在它不再起作用了。 :-(

所以你可以将 swap 放在命名空间 std 中并让它工作。但是你需要记住将 swap 放入 A'当您有模板时，请使用 s 命名空间：A，并且如果您将 swap 放入 A' 中，这两种情况都会起作用。 s 命名空间，只是更容易记住（并教导其他人）以一种方式执行此操作。

Answer 4

（C++ 标准）不允许您重载 std::swap，但是特别允许您将自己类型的模板专业化添加到 std 命名空间。 例如

namespace std
{
    template<>
    void swap(my_type& lhs, my_type& rhs)
    {
       // ... blah
    }
}

，std 容器（以及其他任何地方）中的用法将选择您的专业而不是通用的。

另请注意，提供交换的基类实现对于派生类型来说还不够好。 例如，如果您有

class Base
{
    // ... stuff ...
}
class Derived : public Base
{
    // ... stuff ...
}

namespace std
{
    template<>
    void swap(Base& lha, Base& rhs)
    {
       // ...
    }
}

这将适用于基类，但如果您尝试交换两个派生对象，它将使用 std 中的通用版本，因为模板化交换是完全匹配的（并且它避免了仅交换“基”部分的问题您的派生对象）。

注意：我已更新此内容以删除上一个答案中的错误位。 噢！ （感谢 puetzk 和 j_random_hacker 指出）