Boost C++ Libraries

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` public construct/copy/destruct

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

Effects:

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

`array` iterator support

```
iterator begin();
const_iterator begin() const;
```
Returns:
iterator for the first element

Throws:
will not throw
```
iterator end();
const_iterator end() const;
```
Returns:
iterator for position after the last element

Throws:
will not throw

`array` reverse iterator support

reverse_iterator rbegin();
const_reverse_iterator rbegin() const;

Returns:

reverse iterator for the first element of reverse iteration

```
reverse_iterator rend();
const_reverse_iterator rend() const;
```
Returns:
reverse iterator for position after the last element in reverse iteration

`array` capacity

```
size_type size();
```
Returns:
N
```
bool empty();
```
Returns:
N==0

Throws:
will not throw
```
size_type max_size();
```
Returns:
N

Throws:
will not throw

`array` element access

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

Requires:	`i < N`
Returns:	element with index `i`
Throws:	will not throw.

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

Returns:	element with index `i`
Throws:	`std::range_error` if `i >= N`

```
reference front();
const_reference front() const;
```
Requires:
N > 0

Returns:
the first element

Throws:
will not throw
```
reference back();
const_reference back() const;
```
Requires:
N > 0

Returns:
the last element

Throws:
will not throw
```
const T* data() const;
```
Returns:
elems

Throws:
will not throw
```
T* c_array();
```
Returns:
elems

Throws:
will not throw

`array` modifiers

```
void swap(array<T, N>& other);
```
Effects:
std::swap_ranges(begin(), end(), other.begin())

Complexity:
linear in N
```
void assign(const T& value);
```
Effects:
std::fill_n(begin(), N, value)

`array` specialized algorithms

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

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

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

Returns:

!(x == y)

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

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

Returns:

y < x

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

Returns:

!(y < x)

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

Returns:

!(x < y)

Returns:	iterator for position after the last element
Throws:	will not throw

Requires:	`N > 0`
Returns:	the first element
Throws:	will not throw

Effects:	`std::swap_ranges(begin(), end(), other.begin())`
Complexity:	linear in `N`

Class template array

Synopsis

Description

array public construct/copy/destruct

array iterator support

array reverse iterator support

array capacity

array element access

array modifiers

array specialized algorithms

array comparisons

`array` public construct/copy/destruct

`array` iterator support

`array` reverse iterator support

`array` capacity

`array` element access

`array` modifiers

`array` specialized algorithms

`array` comparisons