Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

This is the documentation for an old version of Boost. Click here to view this page for the latest version.
PrevUpHomeNext

Class template array

boost::array —

STL compliant container wrapper for arrays of constant size

Synopsis

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 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)
Copyright � 2001-2004 Nicolai M. Josuttis

PrevUpHomeNext