How to implement swap()?

Question

Possible Duplicate:
how to provide a swap function for my class?

Every time I think I understand it, I see something that really confuses me.

If you want to provide an implementation of swap for your own class, what do you do?

The list of possibilities is:

1. Define one inside the std namespace (taking two arguments), which calls #3 below
   (some say this is correct; some people say illegal)

2. Define a static method inside the class, taking two arguments to swap
   (makes more sense to me than #4, but I don't get why no one does this), which calls any base-class swaps as necessary

3. Define an instance method inside the class, taking one other argument to swap with, which calls any base-class swaps as necessary

4. Define an instance method inside the class, taking two other arguments to swap, also here, which calls any base-class swaps as necessary

5. Define one in your own namespace (taking two arguments), which calls #3

6. Something else

My own understanding is that I need #5 and #3, where the caller would then be calling swap likeusing std::swap; swap(a, b);,but the fact that no one seems to suggest that combination is really confusing me. And I really don't understand #4 at all, because everyone seems to be using an instance member when in fact the operation is static. I can't tell if my understanding is wrong or a bunch of the answers I see when looking this up.

What's the correct way?

Answer 1

A common pattern I have seen is providing 3 and 5, as per your own understanding.

1. adds an specialization to the std:: namespace, which is allowed, but might not be possible in all cases (if your type is a template itself).
2. offers no advantage at all, and forces qualifying with the type when used outside of one of the members, which means that for implementing swap on other types that hold your type as a member, they will need to qualify the call (void swap( other& l, other& r ) { T::swap( l.t, r.t ); })
3. does not need friendship, allows for use with rvalues (even in C++03) and is idiomatic in some cases std::vector<int>().swap( v ); to clear the contents of the vector.
4. What? You misunderstood the code! That is not declaring a member taking two arguments, but rather a free function taking the two arguments, and defines the function inline. This is equivalent to 5 (without forwarding to 3, but rather implementing everything in the free function).
5. Free function in the same namespace allows for ADL to find it, and enables other code to use the common pattern of void swap( other& l, other& r ) { using std::swap; swap( l.t, r.t ); } without having to know whether the type of other::t has an specific swap overload or the one in std:: needs to be used. Forwarding to 3 allows you to provide a single (real) implementation that can be used through ADL and also on temporary objects.

Answer 2

The C++11 standard says an object t is swappable with an object u if swap(t, u) and swap(u, t) are valid expressions that select non-member functions called swap from an overload set that includes the two std::swap templates in <utility> and any overloads found by Argument Dependent Lookup, such that the values of t and u are exchanged.

The conventional way to swap two objects under the conditions described above is:

using std::swap;
swap(t, u);

Here name lookup will consider std::swap and any overloads of swap found by ADL, then overload resolution will pick the best match.

Considering each of your implementations:

1. It is not legal to add overloads to namespace std, and the rule above doesn't require them to be found anyway. It is legal to specialize the standard std::swap function templates if the specialization is for a user-defined type (i.e. not a standard library type or fundamental type.) If you specialize std::swap it's valid, otherwise not, and you can't partially-specialize function templates.

2. A static member function will not be found by swap(t, u) because it needs to be qualified e.g. Foo::swap(t, u)

3. A unary swap member function cannot be called as swap(t, u), it has to be called as t.swap(u)

4. The links you give show a non-member friend function, which can be found by ADL, so can be used to make types swappable.

5. Such a function can be found by ADL.

So 2 and 3 do not make a type swappable. 4 does, and 5 does. 1 might do, if done correctly, but cannot be used for swapping class templates.

3 is not required, but can be used to help implement either 4 or 5, because a member function will have access to the type's internal details so can swap private members. For 4 the function is a friend, so has access already. So by a process of elimination you need either 4 or 3 and 5. It is generally considered better to provide a member swap (3) and then provide a non-member function in the same namespace (5) which calls the member swap.

Answer 3

As you say, you need #5 (a function in the same namespace as your type) to support the idiomatic using std::swap; swap(a,b);. That way, your overload will be selected by argument-dependent lookup in preference to std::swap.

If your implementation of swap needs to access the type's privates, then you will either need to call a member function like #3, or declare the non-member function a friend. This is what your examples in #4 do: a friend function can be declared and defined inside the class, but that does not make it a member; it is still scoped within the surrounding namespace.

So this:

class thing {
    friend void swap(thing & a, thing & b) {/*whatever*/}
};

is equivalent to this (more or less - see comments):

class thing {
    friend void swap(thing & a, thing & b);
};

inline void swap(thing & a, thing & b) {/*whatever*/}

#1 (specialising std::swap for your type) is allowed, but some would regard it as cleaner to keep everything in your own namespace.

Neither #2 nor #3 would allow an unqualified swap(a,b) to find your implementation.