Why does every STL container have a swap function defined as a member function?

Question

Consider the queue container in the STL.

I understand that swap() , available in the <algorithm> header, will work fine.

I understand that swap() will only copy queue tags, i.e. only the front and rear pointers will be copied along with size and other data members.

Entries in two queues will not physically swap places, but I do not understand why this would be unresolved in any scenario, as soon as the pointers and size are replaced, both queues will be effectively replaced.

Answer 1

Before C ++ 11 introduced the transfer semantics, the general implementation of std::swap had no choice but to make two copies. Conceptually, this is:

 template <class T> void swap(T &a, T &b) { T t(a); a = b; b = t; } 

Note that this generic std::swap does not know anything about the internals of the passed object (because it can be called with an arbitrary user type, for example) and therefore must make copies. Note that for containers, this means copying items.

Providing an optimized swap member function that simply reassigns some internal pointers is therefore a big performance benefit.

Since the semantics of displacement has been introduced, general exchange can be made more efficient using moves. Again, conceptually:

 template <class T> void swap(T &a, T &b) { T t(::std::move(a)); a = ::std::move(b); b = ::std::move(t); } 

Of course, in practice, he probably has requirements that the move operations include not throwing and all kinds of extra bits.

With the semantics of in-place movement, optimized versions of members are perhaps less important than before. But it is still possible that with knowledge of the exact details of the type implementation, their replacement can be faster than three general movements.

---

In addition to the discussion above, note that std::swap overloads exist for almost all types defined in the standard library. What these overloads do is simply invoke the optimized swap member function on one of the operands. Thus, you have the best of both worlds: a common free swap function that can be called with anything, but which optimized implementations for everything the standard library knows about.

It would be possible to abandon the member functions and provide optimized implementations inside the std::swap overloads directly, but this would mean that they probably should be friendly and might be perceived as less accessible for user code.

Answer 2

Since the free std::swap has overloads for each container, you are right that the swap member function is not needed. Free overloads could be declared friend and do all the application-specific container-specific magic to make an efficient swap.

However, they invoke the swap s member. I suppose this provides additional flexibility in how to call these functions, and saves a lot of friend declarations.

I do not know that there is anything else.

Answer 3

When the uniform syntax for invoking a sentence (2014 version of Bjarne Stroustrup) finally, after some final tweaking, your question becomes controversial in the sense that std::swap(my_queue, another_queue) and my_queue.swap(other_queue) are likely to be aliases of the same function itself. Unfortunately, this will not happen for C ++ 17. Maybe in C ++ 20? You can dream ...