如何为我的类型正确专门化 std::swap？

Question

After I've managed to overload std::swap for my class type now I want to specialize it rather than overload it since the standard allows adding template specializations to namespace std . Here is my example:

class Foo{
public:
    Foo(){
        std::cout << "Foo()\n";
    }
    Foo(Foo const&){
        std::cout << "Foo(Foo const&)\n";
    }
    Foo(Foo&&){
        std::cout << "Foo(Foo&&)\n";
    }
    Foo& operator=(Foo const&){
        std::cout << "operator=(Foo const&)\n";
        return *this;
    }
    Foo& operator=(Foo&&){
        std::cout << "operator=(Foo&&)\n";
        return *this;
    }
    ~Foo(){
        std::cout << "~Foo()\n";
    }
};

class VecFoo;
namespace std{
    template <>
    void swap<VecFoo>(VecFoo&, VecFoo&);
}

class VecFoo{
    Foo* pFoo_ = new Foo[10];
    template<>
    friend void std::swap<VecFoo>(VecFoo&, VecFoo&);
};

template <>
void std::swap<VecFo>(VecFoo& lhs, VecFoo& rhs){
    std::cout << "template <> void std::swap(VecFoo&, VecFoo&)\n";
    std::swap(lhs.pFoo_, rhs.pFoo_);
}


int main(){

    VecFoo vf1, vf2;
    using std::swap;
    swap(vf1, vf2);

}

• I don't know why it doesn't compile and I get an error: /usr/include/c++/10/type_traits|2195| required by substitution of 'template<class... _Cond> using _Require = std::__enable_if_t<std::__and_< <template-parameter-1-1> >::value> [with _Cond = {std::__not_<std::__is_tuple_like<VecFoo> >, std::is_move_constructible<VecFoo>, std::is_move_assignable<VecFoo>}]'| /usr/include/c++/10/type_traits|2195| required by substitution of 'template<class... _Cond> using _Require = std::__enable_if_t<std::__and_< <template-parameter-1-1> >::value> [with _Cond = {std::__not_<std::__is_tuple_like<VecFoo> >, std::is_move_constructible<VecFoo>, std::is_move_assignable<VecFoo>}]'|

So what is the problem here and how could I correctly specialize it?

• PS: please don't argue about RAII that I am not achieving in my class VecFoo and the memory leak there because it is not that my problem here.

Answer 1

This is pretty simple really. You don't need the template but you do need to be in the correct namespace.

namespace std {
void swap(VecFoo& lhs, VecFoo& rhs) {
    std::cout << "void swap(VecFoo&, VecFoo&)\n";
    //do your custom swap here!!!
}
}

Answer 2

std::move requires the class to be move-assignable and move-constructible, but the class VecFoo is not any of them.

You added a bunch of method to support these constraints in the class Foo , which didn't requires any (you are swapping pointers).

Also, there is a typo in the swap declaration: it says std::swap<VecFo> instead of std::swap<VecFoo> .

Finally, I would recommend NOT using friend . Just add a method swap to the class and put the logic there.