如何正确，安全地为std :: array实现C ++算术运算符？

Question

I am looking for a correct and safe implementation of C++(17) arithmetic operators for std::array with minimal overhead.

In a first attempt, I tried to achieve the above by implementing such operators as non-member functions and by restricting the arguments taken by the operators to arrays with identical arithmetic value_types and of the same size. Two examples are given below.

template< typename T1, std::size_t N1, typename T2, std::size_t N2 >
constexpr inline auto operator-( const std::array< T1, N1 >& lhs, const std::array< T2, N2 >& rhs )
{
  static_assert( std::is_same< T1, T2 >::value );
  static_assert( std::is_arithmetic< T1 >::value );
  static_assert( N1 == N2 );

  std::array< T1, N1 > result;

  for ( std::size_t i = 0; i < N1; ++i )
  {
    result[ i ] = lhs[ i ] - rhs[ i ];
  }

  return result;
}

template< typename T1, std::size_t N1, typename T2, std::size_t N2 >
constexpr inline auto& operator-=( std::array< T1, N1 >& lhs, const std::array< T2, N2 >& rhs )
{
  static_assert( std::is_same< T1, T2 >::value );
  static_assert( std::is_arithmetic< T1 >::value );
  static_assert( N1 == N2 );

  for ( std::size_t i = 0; i < N1; ++i )
  {
    lhs[ i ] -= rhs[ i ];
  }

  return lhs;
}

I would appreciate suggestions to improve the above attempts. Especially, I am wondering if the restrictions on the arguments are correct and in case of the minus-operator maybe even too strict? Furthermore, I am asking for advice if there is any way to improve the efficiency of the implementations? That is, is there a better way to conduct the actual arithmetic operations than by the for loops given above?

Answer 1

As a general rule, adding non-member operators to a type should be done in the namespace of the type. Without doing that, your operators won't be found via ADL, and that leads to constant pain.

It is not legal to add non-member operators into namespace std .

So the punchline is, don't do this.

Instead, try this:

template<class T, std::size_t N>
struct vecarray : std::array<T,N> {
  static_assert( std::is_arithmetic< T >::value );
  using std::array<T,N>::array;
  vecarray& operator+=( std::array<T,N> const& rhs )& {
    for (auto& x:*this) {
      x += rhs[ std::addressof(x)- this->data() ];
    }
    return *this;
  }
  vecarray& operator-=( std::array<T,N> const& rhs )& {
    for (auto& x:*this) {
      x -= rhs[ std::addressof(x)- this->data() ];
    }
    return *this;
  }
  vecarray& operator*=( std::array<T,N> const& rhs )& {
    for (auto& x:*this) {
      x *= rhs[ std::addressof(x)- this->data() ];
    }
    return *this;
  }
  vecarray& operator/=( std::array<T,N> const& rhs )& {
    for (auto& x:*this) {
      x /= rhs[ std::addressof(x)- this->data() ];
    }
    return *this;
  }

  friend vecarray operator+( vecarray lhs, std::array<T, N> const& rhs ) {
    lhs += rhs;
    return lhs;
  }
  friend vecarray operator-( vecarray lhs, std::array<T, N> const& rhs ) {
    lhs -= rhs;
    return lhs;
  }
  friend vecarray operator*( vecarray lhs, std::array<T, N> const& rhs ) {
    lhs *= rhs;
    return lhs;
  }
  friend vecarray operator/( vecarray lhs, std::array<T, N> const& rhs ) {
    lhs /= rhs;
    return lhs;
  }
};

this has a whole myriad of improvements over your solution. Among them, none of the operators are templates, which generates really annoying errors.