How does “using std::swap” enable ADL?

by

Just wanted to add why this idiom is used at all, which seemed like the spirit of the original question.

This idiom is used within many std library classes where swap is implemented. From http://www.cplusplus.com/reference/algorithm/swap/:

Many components of the standard library (within std) call swap in an
unqualified manner to allow custom overloads for non-fundamental types
to be called instead of this generic version: Custom overloads of swap
declared in the same namespace as the type for which they are provided
get selected through argument-dependent lookup over this generic
version.

So the purpose of using an unqualified “swap” to swap member variables in the function you described is so that ADL can find customized swap functions for those classes (if they exist elsewhere).

Since these customized classes don’t exist within the class you’re referencing (mSize and mArray is a std::size_t and an int*, respectively, in the original example), and the std::swap works just fine, the author added a comment that this was not necessary in this case, but good practice. He would have gotten the same results had he explicitly called std::swap, as is pointed out in the previous answer.

Why is it good practice? Because if you have as members instances of classes for which custom swap is defined, you want the behavior to be this: check for a customized swap function…if it exists, use it, if it does not exist, use the std library functions. In the cases where there are no customized swap functions available, you want it to default to the simple std::swap implementation described in the link above. Hence the “using”, to bring swap for built-in types into the namespace. But those will be tried last.

See also: https://stackoverflow.com/a/2684544/2012659

If for some reason you hate the “using std::swap”, I suppose you could in theory resolve this manually by explicitly calling std::swap for everything you’d want to swap using std::swap and using the unqualified swap for every custom swap you know is defined (still found using ADL). But this is error prone … if you didn’t author those classes you may not know if a customized swap exists for it. And switching between std::swap and swap makes for confusing code. Better to let the compiler handle all of this.

More Related Contents:

  1. Enforcing statement order in C++
  2. SFINAE works differently in cases of type and non-type template parameters
  3. C++ local variable destruction order
  4. C++11 initializer list fails – but only on lists of length 2
  5. `static constexpr` function called in a constant expression is…an error?
  6. Implementation of Permutation, Combinations and PowerSet in C++ [duplicate]
  7. C++11 std::threads vs posix threads
  8. What is the purpose of std::function and how to use it?
  9. Idiomatic Way to declare C++ Immutable Classes
  10. std::this_thread::sleep_for() and GCC
  11. Why isn’t std::array::size static?
  12. How to know underlying type of class enum?
  13. Spurious warning about binding temporary to reference member in constructor
  14. stl container with std::unique_ptr’s vs boost::ptr_container
  15. Specialized template function with deleted “general” case fails to compile with g++
  16. Detect operator support with decltype/SFINAE
  17. Is constexpr really needed?
  18. ISO C++ standard draft
  19. C++: std::move with rvalue reference is not moving contents
  20. Why can’t I use alias from a base class in a derived class with templates?
  21. C++ regex_match not working
  22. C++11: “narrowing conversion inside { }” with modulus
  23. What is std::move(), and when should it be used and does it actually move anything?
  24. std::thread calling method of class [duplicate]
  25. Using data member in lambda capture list inside a member function
  26. Using std::bind with member function, use object pointer or not for this argument?
  27. Write concurrently vector
  28. C++ priority_queue with lambda comparator error
  29. memcpy/memmove to a union member, does this set the ‘active’ member?
  30. Overload resolution with std::function

Leave a Comment