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
-
template<typename U> array& operator=(const array<U, N>& other);
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();
-
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);
-
template<typename T, std::size_t N>
��bool operator!=(const array<T, N>& x, const array<T, N>& y);
-
template<typename T, std::size_t N>
��bool operator<(const array<T, N>& x, const array<T, N>& y);
-
template<typename T, std::size_t N>
��bool operator>(const array<T, N>& x, const array<T, N>& y);
-
template<typename T, std::size_t N>
��bool operator<=(const array<T, N>& x, const array<T, N>& y);
-
template<typename T, std::size_t N>
��bool operator>=(const array<T, N>& x, const array<T, N>& y);