CLASS TEMPLATE ARR(3)

NAME
boost::array - STL compliant container wrapper for arrays of constant size

SYNOPSIS

// In header: <boost/array.hpp>
template<typename T, std::size_t N>
class array {
public:
  // types
  typedef T                                     value_type;
  typedef T*                                    iterator;
  typedef const T*                              const_iterator;
  typedef std::reverse_iterator<iterator>       reverse_iterator;
  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
  typedef T&                                    reference;
  typedef const T&                              const_reference;
  typedef std::size_t                           size_type;
  typedef std::ptrdiff_t                        difference_type;
  // static constants
  static const size_type static_size = N;
  // construct/copy/destruct
  template<typename U> array& operator=(const array<U, N>&);
  // iterator support
  iterator begin();
  const_iterator begin() const;
  iterator end();
  const_iterator end() const;
  // reverse iterator support
  reverse_iterator rbegin();
  const_reverse_iterator rbegin() const;
  reverse_iterator rend();
  const_reverse_iterator rend() const;
  // capacity
  size_type size();
  bool empty();
  size_type max_size();
  // element access
  reference operator[](size_type);
  const_reference operator[](size_type) const;
  reference at(size_type);
  const_reference at(size_type) const;
  reference front();
  const_reference front() const;
  reference back();
  const_reference back() const;
  const T* data() const;
  T* c_array();
  // modifiers
  void swap(array<T, N>&);
  void assign(const T&);
  T elems[N];
};
// specialized algorithms
template<typename T, std::size_t N> void swap(array<T, N>&, array<T, N>&);
// comparisons
template<typename T, std::size_t N>
  bool operator==(const array<T, N>&, const array<T, N>&);
template<typename T, std::size_t N>
  bool operator!=(const array<T, N>&, const array<T, N>&);
template<typename T, std::size_t N>
  bool operator<(const array<T, N>&, const array<T, N>&);
template<typename T, std::size_t N>
  bool operator>(const array<T, N>&, const array<T, N>&);
template<typename T, std::size_t N>
  bool operator<=(const array<T, N>&, const array<T, N>&);
template<typename T, std::size_t N>
  bool operator>=(const array<T, N>&, const array<T, N>&);

DESCRIPTION

  array public construct/copy/destruct

    1.

    template<typename U> array& operator=(const array<U, N>& other);

    Effects:
        std::copy(rhs.begin(),rhs.end(), begin())

  array iterator support

    1.

    iterator begin();
    const_iterator begin() const;

    Returns:
        iterator for the first element

    Throws:
        will not throw

    2.

    iterator end();
    const_iterator end() const;

    Returns:
        iterator for position after the last element

    Throws:
        will not throw

  array reverse iterator support

    1.

    reverse_iterator rbegin();
    const_reverse_iterator rbegin() const;

    Returns:
        reverse iterator for the first element of reverse iteration

    2.

    reverse_iterator rend();
    const_reverse_iterator rend() const;

    Returns:
        reverse iterator for position after the last element in reverse iteration

  array capacity

    1.

    size_type size();

    Returns:
        N

    2.

    bool empty();

    Returns:
        N==0

    Throws:
        will not throw

    3.

    size_type max_size();

    Returns:
        N

    Throws:
        will not throw

  array element access

    1.

    reference operator[](size_type i);
    const_reference operator[](size_type i) const;

    Requires:
        i < N

    Returns:
        element with index i

    Throws:
        will not throw.

    2.

    reference at(size_type i);
    const_reference at(size_type i) const;

    Returns:
        element with index i

    Throws:
        std::range_error if i >= N

    3.

    reference front();
    const_reference front() const;

    Requires:
        N > 0

    Returns:
        the first element

    Throws:
        will not throw

    4.

    reference back();
    const_reference back() const;

    Requires:
        N > 0

    Returns:
        the last element

    Throws:
        will not throw

    5.

    const T* data() const;

    Returns:
        elems

    Throws:
        will not throw

    6.

    T* c_array();

    Returns:
        elems

    Throws:
        will not throw

  array modifiers

    1.

    void swap(array<T, N>& other);

    Effects:
        std::swap_ranges(begin(), end(), other.begin())

    Complexity:
        linear in N

    2.

    void assign(const T& value);

    Effects:
        std::fill_n(begin(), N, value)

  array specialized algorithms

    1.

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

    Effects:
        x.swap(y)

    Throws:
        will not throw.

  array comparisons

    1.

    template<typename T, std::size_t N>
      bool operator==(const array<T, N>& x, const array<T, N>& y);

    Returns:
        std::equal(x.begin(), x.end(), y.begin())

    2.

    template<typename T, std::size_t N>
      bool operator!=(const array<T, N>& x, const array<T, N>& y);

    Returns:
        !(x == y)

    3.

    template<typename T, std::size_t N>
      bool operator<(const array<T, N>& x, const array<T, N>& y);

    Returns:
        std::lexicographical_compare(x.begin(), x.end(), y.begin(), y.end())

    4.

    template<typename T, std::size_t N>
      bool operator>(const array<T, N>& x, const array<T, N>& y);

    Returns:
        y < x

    5.

    template<typename T, std::size_t N>
      bool operator<=(const array<T, N>& x, const array<T, N>& y);

    Returns:
        !(y < x)

    6.

    template<typename T, std::size_t N>
      bool operator>=(const array<T, N>& x, const array<T, N>& y);

    Returns:
        !(x < y)