|  | Home | Libraries | People | FAQ | More | 
        template<class T> void swap(T& left, T&
        right);
      
        The template function boost::swap
        allows the values of two variables to be swapped, using argument dependent
        lookup to select a specialized swap function if available. If no specialized
        swap function is available, std::swap
        is used.
      
        The generic std::swap function requires that the elements
        to be swapped are assignable and copy constructible. It is usually implemented
        using one copy construction and two assignments - this is often both unnecessarily
        restrictive and unnecessarily slow. In addition, where the generic swap implementation
        provides only the basic guarantee, specialized swap functions are often able
        to provide the no-throw exception guarantee (and it is considered best practice
        to do so where possible [1].
      
        The alternative to using argument dependent lookup in this situation is to
        provide a template specialization of std::swap
        for every type that requires a specialized swap. Although this is legal C++,
        no Boost libraries use this method, whereas many Boost libraries provide
        specialized swap functions in their own namespaces.
      
        boost::swap also supports swapping built-in arrays.
        Note that std::swap originally did not do so, but a request
        to add an overload of std::swap
        for built-in arrays has been accepted by the C++ Standards Committee[2].
      
        boost::swap provides the same exception guarantee
        as the underlying swap function used, with one exception; for an array of
        type T[n], where
        n >
        1 and the underlying swap function
        for T provides the strong
        exception guarantee, boost::swap
        provides only the basic exception guarantee.
      
Either:
Or:
swap(T&,T&) is available via argument dependent
            lookup
          Or:
std::swap
            exists for T
          Or:
        Several older compilers do not support argument dependent lookup. On these
        compilers boost::swap will call std::swap,
        ignoring any specialized swap functions that could be found as a result of
        argument dependent lookup.
      
boost::swap less specialized than std::swap, thereby allowing the function
            to have the name 'swap' without introducing ambiguity