namespace std {
     template <typename T, size_t N>
     void swap(T (&lhs)[N], T (&rhs)[N]) {
       swap_ranges(lhs + 0, lhs + N, rhs);
     }
   }

Don't you think so too?

Background:

I was considering adding swap functions to a wrapper class template. In
fact
I had boost::value_initialized in mind, but let's assume that the
wrapper is
simply called W, and defined as follows:

   template <typename T>
   class W {
     public:
       T data;
   };

By definition, both W<int[8]> and W<std::vector<int> > are Swappable,
because they are both CopyConstructible and CopyAssignable. Still for the
sake of efficiency and exception safety, I was considering adding the
following swap function to the namespace of W:

   template <typename T>
   void swap(W<T> & lhs, W<T> & rhs) {
     using std::swap;
     swap(lhs.data, rhs.data);
   }

Note that I'm doing "using std::swap" here, to get the most appropriate
swap
function, as recommended by Scott Meyers' Effective C++, 3rd Edition, item
25, "Consider support for a non-throwing swap".

Unfortunately, after adding this swap function, the following would no
longer compile:

   int main() {
     W<int[8]> w1, w2;
     using std::swap;
     swap(w1, w2);
   }

The problem would be fixed by providing an overload of std::swap for
C-style
arrays.  Moreover, if this overload would be implemented in terms of
swapping the elements of the array, it would be non-throwing for those
element types that have a non-throwing swap.

Your feedback is appreciated...

Kind regards,
--
Niels Dekker
http://www.xs4all.nl/~nd/dekkerware
Scientific programmer at LKEB, Leiden University Medical Center

In my view, the next C++ Standard would better serve C++ programmers -
not by enhancing the appeal of C-style arrays - but rather by
promoting the adoption of their equally efficient - but safer
replacement - the C++ "std::array". Moreover, std::array - exactly as
one would expect of a C++ Standard Library class template - does
implement a swap() method.

Greg

   23.2.1.2 array specialized algorithms [array.special]

   template <class T, size_t N>
       void swap(array<T,N>& x, array<T,N>& y);
   Effects:
   swap_ranges(x.begin(), x.end(), y.begin() );

But still I think that std::swap should support C-style arrays as well.
Howard Hinnant already wrote to me that he can make it an issue for the
Library Working Group (LWG).  :-)  One more technical question, though.
In my previous posting I suggested implementing an std::swap overload
for C-style arrays as follows:

     template <typename T, size_t N>
     void swap(T (&lhs)[N], T (&rhs)[N]) {
       swap_ranges(lhs + 0, lhs + N, rhs);
     }

Do you know if this addition of zero, "lhs + 0", is really necessary (to
make sure that the first and the second argument are of the same type)?
If so, should the third argument passed to swap_ranges also have an
addition of zero, "rhs + 0" (to make sure that the third argument is a
ForwardIterator)?

Kind regards, Niels

template <class T, size_t N> void swap(array<T,N>& x, array<T,N>& y);

        Effects:
          swap_ranges(x.begin(), x.end(), y.begin() );

If there is a simple fix fine, let the working group fix it.   But I
think the array depreciation to ptr will kick in....

Greg Herlihy repied:

Anyway, please take another look at my wrapper example:

   // Wrapper:
   template <typename T>
   class W {
     public:
       T data;
   };

   // Its swap function:
   template <typename T>
   void swap(W<T> & lhs, W<T> & rhs) {
     using std::swap;
     swap(lhs.data, rhs.data);
   }

W<int[8]> is Swappable, but an attempt to swap two instances of
W<int[8]> would be rejected by the compiler:

   W<int[8]> w1, w2;  // So w1 and w2 are Swappable.
   swap(w1, w2);  // Rejected!

I think that's an inconsistency that should be fixed.

Kind regards,

   Niels

On 23 Feb, 07:14, Greg Herlihy <gre...@mac.com> wrote:

#define SEQ (1)(2)(3)

#define ARRAY_MACRO(R,D,E)  E,

//BOOST_PP_SEQ_FOR_EACH(ARRAY_MACRO,_,SEQ)

#define MAKE_ARRAY(TYPE,NAME,INIT)\
boost::array<TYPE,BOOST_PP_SEQ_SIZE(INIT)>\
    NAME = { BOOST_PP_SEQ_FOR_EACH(ARRAY_MACRO,_,\
       INIT)}

#if 0
#include <boost/array.hpp>
#endif

MAKE_ARRAY(int,a,SEQ);

MAKE_ARRAY(int,b,(1)(2)(3));

#undef ARRAY_MACRO

   template <typename T, size_t N>
     void swap(T (&lhs)[N], T (&rhs)[N]);

I just double-checked section 14.8.2.1, Deducing template arguments from
a function call [temp.deduct.call], from the Draft (N2521).  It *only*
says that array-to-pointer conversion is applied to an argument if the
corresponding function template parameter type (P) is *not* a reference
type.  But in the case of std::swap, both of the function template
parameters (lhs, rhs) are references.  So in this case, array-to-pointer
convertion is not applied, during template argument deduction.

Kind regards, Niels

   LWG issue 809: std::swap should be overloaded for array types
   http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-active.html#809

Thanks to Howard Hinnant,

Kind regards,

Niels