swap

类的swap

#include <vector>
#include <memory>

class WidgetImpl
{
public:
    WidgetImpl() = default;
    ~WidgetImpl() = default;

private:
    int m_a, m_b, m_c;
    std::vector<double> m_v;
};

class Widget
{
public:
    Widget() : m_Impl(new WidgetImpl){}
    ~Widget()= default;
    Widget & operator=(const Widget & rhs)
    {
        *m_Impl = *(rhs.m_Impl);
        return *this;
    }

    void swap(Widget &other) {
        std::swap(m_Impl, other.m_Impl);
    }

private:
    std::shared_ptr<WidgetImpl> m_Impl;
};

// 通常不允许改变std命名空间内的任何东西,但可以为标准templates(如swap)制造特化版本
namespace std {
    template<>  // 表示是std::swap的一个total template specialization版本
    void swap<Widget>(Widget &a, Widget &b) // 函数名之后的<Widget>表示这一特化版本针对"T是Widget"而设计
    {
        a.swap(b);
    }
}
using namespace std;
int main() {
    Widget aw;
    Widget bw;
    swap(aw, bw);

    return 0;
}

class templates的swap

#include <vector>
#include <memory>

namespace WidgetStuff
{
    template<typename T>
    class WidgetImpl
    {
    public:
        WidgetImpl() = default;
        ~WidgetImpl() = default;

    private:
        T m_a, m_b, m_c;
        std::vector<T> m_v;
    };

    template<typename T>
    class Widget
    {
    public:
        Widget() : m_Impl(new WidgetImpl<T>) {}
        ~Widget() = default;
        Widget & operator=(const Widget & rhs)
        {
            *m_Impl = *(rhs.m_Impl);
            return *this;
        }

        void swap(Widget &other) {
            std::swap(m_Impl, other.m_Impl);
        }

    private:
        std::shared_ptr<WidgetImpl<T> > m_Impl;
    };

    template<typename T>
    void swap(Widget<T> &a, Widget<T> &b)
    {
        a.swap(b);
    }
}

#if 0  // 重载function templates没有问题,但在std里实现是跨越红线的行为,虽然仍可编译和运行。
namespace std {
    template<typename T>
    void swap(WidgetStuff::Widget<T> &a, WidgetStuff::Widget<T> &b)
    {
        a.swap(b);
    }
}
#endif

using namespace std;

int main() {
    WidgetStuff::Widget<int> aw;
    WidgetStuff::Widget<int> bw;
    swap(aw, bw);  // 实际调用的是WidgetStuff::swap,不需要显示写成WidgetStuff::swap(aw, bw);
                   // 依据Koenig Lookup/Argument Dependent Lookup (ADL)
                   // 来从aw和bw所在的namespace中找到WidgetStuff::swap

    int a = 2, b = 3;
    swap(a,b);    // 实际调用的是std::swap

    return 0;
}