| Home | Libraries | People | FAQ | More

## Class template array

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;
      const_iterator cbegin();
      const_iterator cend();

      // reverse iterator support
      reverse_iterator rbegin();
      const_reverse_iterator rbegin() const;
      reverse_iterator rend();
      const_reverse_iterator rend() const;
      const_reverse_iterator crbegin();
      const_reverse_iterator crend();

      // 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&);

      // public data members
      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>&);

    // specializations
    template<typename T, std::size_t N, std::size_t Idx>
      T boost::get(array<T, N>&);
    template<typename T, std::size_t N, std::size_t Idx>
      T boost::get(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

3.     const_iterator cbegin();

   Returns: | constant iterator for the first element
   Throws: | will not throw

4.     const_iterator cend();

   Returns: | constant 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

3.     const_reverse_iterator crbegin();

   Returns: | constant reverse iterator for the first element of reverse iteration
   Throws: | will not throw

4.     const_reverse_iterator crend();

   Returns: | constant reverse iterator for position after the last element in reverse iteration
   Throws: | will not throw

### `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)`

### `array` specializations

1.     template<typename T, std::size_t N, std::size_t Idx>
         T boost::get(array<T, N>& arr);

   Returns: | element of array with index `Idx`
   Effects: | Will `static_assert` if `Idx >= N`

2.     template<typename T, std::size_t N, std::size_t Idx>
         T boost::get(const array<T, N>& arr);

   Returns: | const element of array with index `Idx`
   Effects: | Will `static_assert` if `Idx >= N`