Boost C++ Libraries Home Libraries People FAQ More

PrevUpHomeNext

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;

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

PrevUpHomeNext