how to provide a swap function for my class?

by
  1. is the proper use of swap. Write it this way when you write “library” code and want to enable ADL (argument-dependent lookup) on swap. Also, this has nothing to do with SFINAE.
// some algorithm in your code
template<class T>
void foo(T& lhs, T& rhs) {
    using std::swap; // enable 'std::swap' to be found
                    // if no other 'swap' is found through ADL
    // some code ...
    swap(lhs, rhs); // unqualified call, uses ADL and finds a fitting 'swap'
                    // or falls back on 'std::swap'
    // more code ...
}
  1. Here is the proper way to provide a swap function for your class:
namespace Foo {

class Bar{}; // dummy

void swap(Bar& lhs, Bar& rhs) {
    // ...
}

}

If swap is now used as shown in 1), your function will be found. Also, you may make that function a friend if you absolutely need to, or provide a member swap that is called by the free function:

// version 1
class Bar{
public:
    friend void swap(Bar& lhs, Bar& rhs) {
    // ....
    }
};

// version 2
class Bar{
public:
    void swap(Bar& other) {
    // ...
    }
};

void swap(Bar& lhs, Bar& rhs) {
    lhs.swap(rhs);
}

...
  1. You mean an explicit specialization. Partial is still something else and also not possible for functions, only structs / classes. As such, since you can’t specialize std::swap for template classes, you have to provide a free function in your namespace. Not a bad thing, if I may say so. Now, an explicit specialization is also possible, but generally you do not want to specialize a function template:
namespace std
{  // only allowed to extend namespace std with specializations

template<> // specialization
void swap<Bar>(Bar& lhs, Bar& rhs) noexcept {
    // ...
}

}
  1. No, as 1) is distinct from 2) and 3). Also, having both 2) and 3) will lead to always having 2) picked, because it fits better.

More Related Contents:

  1. In which scenario do I use a particular STL container?
  2. C++ sorting and keeping track of indexes
  3. What are the complexity guarantees of the standard containers?
  4. Remove spaces from std::string in C++
  5. How do I sort a std::vector by the values of a different std::vector?
  6. Why should one not derive from c++ std string class?
  7. problem sorting using member function as comparator
  8. Is the size of std::array defined by standard
  9. Looking for C++ STL-like vector class but using stack storage
  10. Difference between erase and remove
  11. Why is the C++ initializer_list behavior for std::vector and std::array different?
  12. Appending a vector to a vector [duplicate]
  13. Is there a way to access the underlying container of STL container adaptors?
  14. Sorting a vector in descending order
  15. Why is it OK to return a ‘vector’ from a function?
  16. vector::at vs. vector::operator[]
  17. c++ exception : throwing std::string
  18. How does the standard library implement std::swap?
  19. How can currying be done in C++?
  20. Why don’t the std::fstream classes take a std::string?
  21. how portable is end iterator decrement?
  22. Sorting a std::vector by the string?
  23. Template class with template container
  24. Windows Unicode C++ Stream Output Failure
  25. Can raw pointers be used instead of iterators with STL algorithms for containers with linear storage?
  26. STL remove doesn’t work as expected?
  27. std::back_inserter for a std::set?
  28. Converting between C++ std::vector and C array without copying
  29. C++, can I statically initialize a std::map at compile time?
  30. list of polymorphic objects

Leave a Comment