Class template array . Boost , The Boost C++ Libraries BoostBook Documentation Subset , Reference

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

Description

`array` public construct/copy/destruct

<
```
template<typenameU>array&operator=(constarray<U,N>&other);
```
>
Эффекты:
<std::copy(rhs.begin(),rhs.end(),begin())>

`array` iterator support

<
```
iteratorbegin();
const_iteratorbegin()const;
```
>
Возвращение:
итератор для первого элемента
Броски:
не будут бросать
<
```
iteratorend();
const_iteratorend()const;
```
>
Возвращение:
итератор для положения после последнего элемента
Броски:
не будут бросать

`array` reverse iterator support

<
```
reverse_iteratorrbegin();
const_reverse_iteratorrbegin()const;
```
>
Возврат:
обратный итератор для первого элемента обратной итерации
<
```
reverse_iteratorrend();
const_reverse_iteratorrend()const;
```
>
Возвращение:
обратный итератор для положения после последнего элемента в обратной итерации

`array` capacity

<
```
size_typesize();
```
>
Возвращение:
<N>
<
```
boolempty();
```
>
Возвращение:
<N==0>
Броски:
не будут бросать
<
```
size_typemax_size();
```
>
Возвращение:
Броски:
не бросят

`array` element access

<
```
referenceoperator[](size_typei);
const_referenceoperator[](size_typei)const;
```
>
Требуется:
<i < N>
Возврат:
элемент с индексом<i>
Броски:
не бросят.
<
```
referenceat(size_typei);
const_referenceat(size_typei)const;
```
>
Возврат:
элемент с индексом<i>
Бросок:
<std::range_error>, если<i >= N>
<
```
referencefront();
const_referencefront()const;
```
>
<N > 0>
Требуется:
Возвращение:
Первый элемент
Броски:
не бросают
<
```
referenceback();
const_referenceback()const;
```
>
Требуется:
<N > 0>
Возвращение:
Последний элемент
Броски:
не бросят
<
```
constT*data()const;
```
>
Возвращение:
<elems>
Броски:
не бросят
<
```
T*c_array();
```
>
Возвращение:
<elems>
Броски:
не бросят

`array` modifiers

<
```
voidswap(array<T,N>&other);
```
>
Эффекты:
<std::swap_ranges(begin(),end(), other.begin())>
Сложность:
линейная в<N>
<
```
voidassign(constT&value);
```
>
Эффекты:
<std::fill_n(begin(), N, value)>

`array` specialized algorithms

template<typenameT,std::size_tN>voidswap(array<T,N>&x,array<T,N>&y);

Эффекты:

Броски:

не бросают.

`array` comparisons

template<typenameT,std::size_tN>
 booloperator==(constarray<T,N>&x,constarray<T,N>&y);

Возвращение:

<std::equal(x.begin(), x.end(), y.begin())>

template<typenameT,std::size_tN>
 booloperator!=(constarray<T,N>&x,constarray<T,N>&y);

Возвращение:

<!(x == y)>

<
```
template<typenameT,std::size_tN>
 booloperator<(constarray<T,N>&x,constarray<T,N>&y);
```
>
Возвращение:
<std::lexicographical_compare(x.begin(), x.end(), y.begin(), y.end())>

template<typenameT,std::size_tN>
 booloperator>(constarray<T,N>&x,constarray<T,N>&y);

Возвращение:

<y < x>

template<typenameT,std::size_tN>
 booloperator<=(constarray<T,N>&x,constarray<T,N>&y);

Возвращение:

<!(y < x)>

template<typenameT,std::size_tN>
 booloperator>=(constarray<T,N>&x,constarray<T,N>&y);

Возвращение:

<!(x < y)>

Статья Class template array раздела The Boost C++ Libraries BoostBook Documentation Subset Reference может быть полезна для разработчиков на c++ и boost.

Материалы статей собраны из открытых источников, владелец сайта не претендует на авторство. Там где авторство установить не удалось, материал подаётся без имени автора. В случае если Вы считаете, что Ваши права нарушены, пожалуйста, свяжитесь с владельцем сайта.

:: Главная :: Reference ::

Время компиляции файла: 2024-08-30 11:47:00
2025-05-19 20:21:06/0.029875993728638/1

Class template array

Boost , The Boost C++ Libraries BoostBook Documentation Subset , Reference

Boost C++ Libraries

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