Array Components . Boost , The Boost C++ Libraries BoostBook Documentation Subset , Chapter 25. Boost.MultiArray Reference Manual

Array Components

multi_array
multi_array_ref
const_multi_array_ref

Повышаю. MultiArray определяет класс массива,multi_arrayи два адаптерных классаmulti_array_refиconst_multi_array_ref. Три класса модели MultiArray и поэтому они имеют много функций.multi_array_refОтличается отmulti_arrayв том, чтомульти-мультипликаторуправляет собственной памятью, в то время какmulti_array_refПередается блок памяти, которым предполагается управлять извне.const_multi_array_refотличается отmulti_array_refв том, что базовые элементы, которые он адаптирует, не могут быть изменены через его интерфейс, хотя некоторые свойства массива, включая форму массива и базы индексов, могут быть изменены. Функциональность, которую имеют классы, описана ниже.

Примечание: Предварительные условия, эффекты и реализация. В следующих разделах используются небольшие фрагменты кода C++ для указания ограничений, таких как предварительные условия, эффекты и постусловия. Они не обязательно описывают базовую реализацию компонентов массива; скорее, они описывают ожидаемый вход и поведение указанных операций. Невыполнение предварительных условий приводит к неопределенному поведению. Не все эффекты (например, конструкторы копий и т. д.) должны точно имитироваться. Сниппеты кода для эффектов предназначены для захвата сущности описанной операции.

Вопросы.

element* data(); const element* data() const;: Это возвращает указатель к началу смежного блока, который содержит данные массива. Если все размеры массива 0-индексированы и хранятся в порядке возрастания, это эквивалентноисточнику().. Обратите внимание, чтоconst_multi_array_refпредоставляет только конст-версию этой функции.
element* origin(); const element* origin() const;: Это возвращает исходный элементmulti_array. Обратите внимание, чтоconst_multi_array_refпредоставляет только конст-версию этой функции. (перенаправлено с «MultiArray»)
const index* index_bases();: Это возвращает индексные базы дляmulti_array. (перенаправлено с «MultiArray»)
const index* strides();: Это возвращает шаги длямульти-массив. (перенаправлено с «MultiArray»)
const size_type* shape();: Это возвращает формуmulti_array. (перенаправлено с «MultiArray»)

Сравнители.

bool operator==(const *array-type*& rhs); bool operator!=(const *array-type*& rhs); bool operator<(const *array-type*& rhs); bool operator>(const *array-type*& rhs); bool operator>=(const *array-type*& rhs); bool operator<=(const *array-type*& rhs);

Каждый компаратор выполняет лексикографическое сравнение по типам значений двух массивов. (перенаправлено с «MultiArray»)

Предпосылки. Элементдолжен поддерживать компаратор, соответствующий тому, который вызываетсяmulti_array.

Сложность. Onum_elements().

Модификаторы.

template <typename SizeList> void reshape(const SizeList& sizes)

Это меняет формуmulti_array. Число элементов и индексные базы остаются неизменными, но число значений на каждом уровне вложенной иерархии контейнеров может меняться.

SizeListТребования. SizeListдолжна быть модельюКоллекция.

Preconditions.

std::accumulate(sizes.begin(),sizes.end(),size_type(1),std::times<size_type>()) == this->num_elements();
sizes.size() == NumDims;

Postconditions. std::equal(sizes.begin(),sizes.end(),this->shape) == true;

template <typename BaseList> void reindex(const BaseList& values);

Это изменяет индексные базыmulti_array, чтобы соответствовать значениям взначениях.

Базовый списокТребования. Базовый листдолжен быть смоделированКоллекция.

Предпосылки. Значения. размер() == NumDims;

Postconditions. std::equal(values.begin(),values.end(),this->index_bases());

void reindex(index value);

Это изменяет индексные базы всех измеренийmulti_arrayдозначения.

Postconditions.

std::count_if(this->index_bases(),this->index_bases()+this->num_dimensions(),
              std::bind_2nd(std::equal_to<index>(),value)) == 
              this->num_dimensions();

`multi_array`

multi_array— многомерный контейнер, поддерживающий итерацию случайного доступа. Его количество измерений фиксируется во время компиляции, но его форма и количество элементов, которые он содержит, уточняются при его построении. Количество элементов будет оставаться фиксированным в течение срока службымноголучевой матрицы, но форма контейнера может быть изменена.multi_arrayуправляет своими элементами данных с помощью сменного распределителя.

Model Of. MultiArray,CopyConstructible. В зависимости от типа элемента он также может моделироватьEqualityComparableиLessThanComparable.

Синопсис.

namespace boost {
template <typename ValueType, 
          std::size_t NumDims, 
          typename Allocator = std::allocator<ValueType> >
class multi_array {
public:
// types:
  typedef ValueType                             element;
  typedef *unspecified*                         value_type;
  typedef *unspecified*                         reference;
  typedef *unspecified*                         const_reference;
  typedef *unspecified*                         difference_type;
  typedef *unspecified*                         iterator;
  typedef *unspecified*                         const_iterator;
  typedef *unspecified*                         reverse_iterator;
  typedef *unspecified*                         const_reverse_iterator;
  typedef multi_array_types::size_type          size_type;
  typedef multi_array_types::index              index;
  typedef multi_array_types::index_gen          index_gen;
  typedef multi_array_types::index_range        index_range;
  typedef multi_array_types::extent_gen         extent_gen;
  typedef multi_array_types::extent_range       extent_range;
  typedef *unspecified*                         storage_order_type;
  // template typedefs
  template <std::size_t Dims> struct            subarray;
  template <std::size_t Dims> struct            const_subarray;
  template <std::size_t Dims> struct            array_view;
  template <std::size_t Dims> struct            const_array_view;
  
  static const std::size_t dimensionality = NumDims;
  
  // constructors and destructors
  multi_array();
  template <typename ExtentList>
  explicit multi_array(const ExtentList& sizes,
                       const storage_order_type& store = c_storage_order(),
                       const Allocator& alloc = Allocator());
  explicit multi_array(const extents_tuple& ranges,
                       const storage_order_type& store = c_storage_order(),
	               const Allocator& alloc = Allocator());
  multi_array(const multi_array& x);
  multi_array(const const_multi_array_ref<ValueType,NumDims>& x);
  multi_array(const const_subarray<NumDims>::type& x);
  multi_array(const const_array_view<NumDims>::type& x);
  multi_array(const multi_array_ref<ValueType,NumDims>& x);
  multi_array(const subarray<NumDims>::type& x);
  multi_array(const array_view<NumDims>::type& x);
  ~multi_array();
  // modifiers
  multi_array& operator=(const multi_array& x);
  template <class Array> multi_array& operator=(const Array& x);
  // iterators:
  iterator				begin();
  iterator				end();
  const_iterator			begin() const;
  const_iterator			end() const;
  reverse_iterator			rbegin();
  reverse_iterator			rend();
  const_reverse_iterator		rbegin() const;
  const_reverse_iterator		rend() const;
  // capacity:
  size_type				size() const;
  size_type				num_elements() const;
  size_type				num_dimensions() const;
 
  // element access:
  template <typename IndexList> 
    element&			operator()(const IndexList& indices);
  template <typename IndexList>
    const element&		operator()(const IndexList& indices) const;
  reference			operator[](index i);
  const_reference		operator[](index i) const;
  array_view<Dims>::type	operator[](const indices_tuple& r);
  const_array_view<Dims>::type	operator[](const indices_tuple& r) const;
  // queries
  element*			data();
  const element*		data() const;
  element*			origin();
  const element*		origin() const;
  const size_type*		shape() const;
  const index*			strides() const;
  const index*			index_bases() const;
  const storage_order_type&     storage_order() const;
  // comparators
  bool operator==(const multi_array& rhs);
  bool operator!=(const multi_array& rhs);
  bool operator<(const multi_array& rhs);
  bool operator>(const multi_array& rhs);
  bool operator>=(const multi_array& rhs);
  bool operator<=(const multi_array& rhs);
  // modifiers:
  template <typename InputIterator>
    void			assign(InputIterator begin, InputIterator end);
  template <typename SizeList>
    void			reshape(const SizeList& sizes)
  template <typename BaseList>	void reindex(const BaseList& values);
    void			reindex(index value);
  template <typename ExtentList>
    multi_array&		resize(const ExtentList& extents);
  multi_array&                  resize(extents_tuple& extents);
};

Конструкторы.

template <typename ExtentList> explicit multi_array(const ExtentList& sizes, const storage_order_type& store = c_storage_order(), const Allocator& alloc = Allocator());

Это создаетmulti_arrayс использованием заданных параметров.размерыопределяют форму построенногомноголучевого массива.хранилищеопределяет порядок хранения или компоновку в памяти размеров массива.аллокиспользуется для выделения содержащихся элементов.

ExtentList Requirements. ExtentList must model Collection.

Предпосылки. Размеры.размер() == NumDims

explicit multi_array(extent_gen::gen_type<NumDims>::type ranges, const storage_order_type& store = c_storage_order(), const Allocator& alloc = Allocator());

Это создаетmulti_arrayс использованием заданных параметров.диапазоныопределяют форму и индексные основания построенного многолучевого массива. Это результатNumDimsпривязанных вызововextent_gen::operator[].storeопределяет порядок хранения или компоновку в памяти размеров массива.alloc— это распределитель, используемый для выделения памяти, используемой для храненияэлементов multi_array.

multi_array(const multi_array& x); multi_array(const const_multi_array_ref<ValueType,NumDims>& x); multi_array(const const_subarray<NumDims>::type& x); multi_array(const const_array_view<NumDims>::type& x); multi_array(const multi_array_ref<ValueType,NumDims>& x); multi_array(const subarray<NumDims>::type& x); multi_array(const array_view<NumDims>::type& x);

Все эти конструкторы строятmulti_arrayи выполняют глубокую копиюx.

Сложность. Это выполняет O(x.num_elements()) вызовы кэлементуконструктора копий.

multi_array();

Это конструируетмноголучевой, форма которого (0, ...,0) и не содержит элементов.

Примечание к Конструкторам. Выражения конструкцииmulti_array

     multi_array<int,3> A(boost::extents[5][4][3]);

     boost::array<multi_array_base::index,3> my_extents = {{5, 4, 3}};
     multi_array<int,3> A(my_extents);

являются эквивалентными.

Модификаторы.

multi_array& operator=(const multi_array& x); template <class Array> multi_array& operator=(const Array& x);

Это выполняет элементную копиюxв текущиймульти-массив.

РешеткаТребования. Решеткадолжна моделировать MultiArray.

Preconditions.

std::equal(this->shape(),this->shape()+this->num_dimensions(),
x.shape());

Postconditions.

(*.this) == x;

Сложность. Операторы присваивания выполняют O(x.num_elements()) вызовы кэлементуконструктора копий.

template <typename InputIterator> void assign(InputIterator begin, InputIterator end);

Это копирует элементы в диапазоне[начало, конец]в массив. Это эквивалентноstd::copy(begin,end,this->data()).

Предпосылки. std::distance(begin,end) == this->num_elements();

Сложность. Функцияприсвоитьчлен выполняет O(это->num_elements()) вызовыконструктора копий ValueType.

multi_array& resize(extent_gen::gen_type<NumDims>::type extents); template <typename ExtentList> multi_array& resize(const ExtentList& extents);

Эта функция изменяет размер массива до формы, указанной встепени, которая является либо сгенерированным списком степеней, либо моделью концепцииCollection. Содержимое массива сохраняется, когда это возможно; если новый размер массива меньше, то некоторые данные будут потеряны. Любые новые элементы, созданные путем изменения размера массива, инициализируются с помощью конструктора по умолчаниюэлемента.

Вопросы.

storage_order_type& storage_order() const;: Этот запрос возвращает объект заказа хранения, связанный сmulti_array. Он может быть использован для создания нового массива с тем же порядком хранения.

`multi_array_ref`

multi_array_ref— многомерный контейнерный адаптер. Он обеспечивает интерфейс MultiArray над любым смежным блоком элементов.multi_array_refэкспортирует тот же интерфейс, что иmulti_array, за исключением конструкторов.

Модель Of. multi_array_refмоделиMultiArray,CopyConstructibleи в зависимости от типа элемента, он также может моделироватьEqualityComparableиLessThanComparable. Подробные описания приведены здесь только для операций, которые не описаны в ссылкеmulti_array.

Синопсис.

namespace boost {
template <typename ValueType, 
          std::size_t NumDims>
class multi_array_ref {
public:
// types:
  typedef ValueType                             element;
  typedef *unspecified*                         value_type;
  typedef *unspecified*                         reference;
  typedef *unspecified*                         const_reference;
  typedef *unspecified*                         difference_type;
  typedef *unspecified*                         iterator;
  typedef *unspecified*                         const_iterator;
  typedef *unspecified*                         reverse_iterator;
  typedef *unspecified*                         const_reverse_iterator;
  typedef multi_array_types::size_type          size_type;
  typedef multi_array_types::index              index;
  typedef multi_array_types::index_gen          index_gen;
  typedef multi_array_types::index_range        index_range;
  typedef multi_array_types::extent_gen         extent_gen;
  typedef multi_array_types::extent_range       extent_range;
  typedef *unspecified*                         storage_order_type;
  
  // template typedefs
  template <std::size_t Dims> struct            subarray;
  template <std::size_t Dims> struct            const_subarray;
  template <std::size_t Dims> struct            array_view;
  template <std::size_t Dims> struct            const_array_view;
  
  static const std::size_t dimensionality = NumDims;
  // constructors and destructors
  template <typename ExtentList>
  explicit multi_array_ref(element* data, const ExtentList& sizes,
                       const storage_order_type& store = c_storage_order());
  explicit multi_array_ref(element* data, const extents_tuple& ranges,
                       const storage_order_type& store = c_storage_order());
  multi_array_ref(const multi_array_ref& x);
  ~multi_array_ref();
  // modifiers
  multi_array_ref& operator=(const multi_array_ref& x);
  template <class Array> multi_array_ref& operator=(const Array& x);
  // iterators:
  iterator				begin();
  iterator				end();
  const_iterator			begin() const;
  const_iterator			end() const;
  reverse_iterator			rbegin();
  reverse_iterator			rend();
  const_reverse_iterator		rbegin() const;
  const_reverse_iterator		rend() const;
  // capacity:
  size_type				size() const;
  size_type				num_elements() const;
  size_type				num_dimensions() const;
 
  // element access:
  template <typename IndexList> 
    element&			operator()(const IndexList& indices);
  template <typename IndexList>
    const element&		operator()(const IndexList& indices) const;
  reference			operator[](index i);
  const_reference		operator[](index i) const;
  array_view<Dims>::type	operator[](const indices_tuple& r);
  const_array_view<Dims>::type	operator[](const indices_tuple& r) const;
  // queries
  element*			data();
  const element*		data() const;
  element*			origin();
  const element*		origin() const;
  const size_type*		shape() const;
  const index*			strides() const;
  const index*			index_bases() const;
  const storage_order_type&     storage_order() const;
  // comparators
  bool operator==(const multi_array_ref& rhs);
  bool operator!=(const multi_array_ref& rhs);
  bool operator<(const multi_array_ref& rhs);
  bool operator>(const multi_array_ref& rhs);
  bool operator>=(const multi_array_ref& rhs);
  bool operator<=(const multi_array_ref& rhs);
  // modifiers:
  template <typename InputIterator>
    void			assign(InputIterator begin, InputIterator end);
  template <typename SizeList>
    void			reshape(const SizeList& sizes)
  template <typename BaseList>	void reindex(const BaseList& values);
  void				reindex(index value);
};

Конструкторы.

template <typename ExtentList> explicit multi_array_ref(element* data, const ExtentList& sizes, const storage_order& store = c_storage_order(), const Allocator& alloc = Allocator());

Это создаетmulti_array_refс использованием заданных параметров.размерыопределяют форму построенногоmulti_array_ref.хранилищеопределяет порядок хранения или компоновку в памяти размеров массива.allocиспользуется для выделения содержащихся элементов.

ExtentList Requirements. ExtentList must model Collection.

Предпосылки. Размеры.размер() == NumDims

explicit multi_array_ref(element* data, extent_gen::gen_type<NumDims>::type ranges, const storage_order& store = c_storage_order());

Это создаетmulti_array_refс использованием заданных параметров.диапазоныопределяют форму и индексные основания построенного мульти-мультипликатора. Это результатNumDimsпривязанных вызововextent_gen::operator [].storeопределяет порядок хранения или компоновку в памяти размеров массива.

multi_array_ref(const multi_array_ref& x);

Это создает неглубокую копиюx.

Сложность. Постоянное время (для сравнения, сравните это смноголучевымконструктором копий класса).

Модификаторы.

multi_array_ref& operator=(const multi_array_ref& x); template <class Array> multi_array_ref& operator=(const Array& x);

Это выполняет элементную копиюxв текущийmulti_array_ref.

РешеткаТребования. Решеткадолжна моделировать MultiArray.

Preconditions.

std::equal(this->shape(),this->shape()+this->num_dimensions(),
x.shape());

Postconditions.

(*.this) == x;

Сложность. Операторы присваивания выполняют O(x.num_elements()) вызовы кэлементуконструктора копий.

`const_multi_array_ref`

const_multi_array_ref is a multi-dimensional container adaptor. It provides the MultiArray interface over any contiguous block of elements. const_multi_array_ref exports the same interface as multi_array, with the exception of the constructors.

Модель Of. const_multi_array_refмоделиMultiArray,CopyConstructible. и в зависимости от типа элемента, он также может моделироватьEqualityComparableиLessThanComparable. Подробные описания приведены здесь только для операций, которые не описаны в ссылкеmulti_array.

Синопсис.

namespace boost {
template <typename ValueType, 
          std::size_t NumDims, 
          typename TPtr = const T*>
class const_multi_array_ref {
public:
// types:
  typedef ValueType                             element;
  typedef *unspecified*                         value_type;
  typedef *unspecified*                         reference;
  typedef *unspecified*                         const_reference;
  typedef *unspecified*                         difference_type;
  typedef *unspecified*                         iterator;
  typedef *unspecified*                         const_iterator;
  typedef *unspecified*                         reverse_iterator;
  typedef *unspecified*                         const_reverse_iterator;
  typedef multi_array_types::size_type          size_type;
  typedef multi_array_types::index              index;
  typedef multi_array_types::index_gen          index_gen;
  typedef multi_array_types::index_range        index_range;
  typedef multi_array_types::extent_gen         extent_gen;
  typedef multi_array_types::extent_range       extent_range;
  typedef *unspecified*                         storage_order_type;
  
  // template typedefs
  template <std::size_t Dims> struct            subarray;
  template <std::size_t Dims> struct            const_subarray;
  template <std::size_t Dims> struct            array_view;
  template <std::size_t Dims> struct            const_array_view;
  
  // structors
  template <typename ExtentList>
  explicit const_multi_array_ref(TPtr data, const ExtentList& sizes,
                       const storage_order_type& store = c_storage_order());
  explicit const_multi_array_ref(TPtr data, const extents_tuple& ranges,
                       const storage_order_type& store = c_storage_order());
  const_multi_array_ref(const const_multi_array_ref& x);
  ~const_multi_array_ref();
  // iterators:
  const_iterator			begin() const;
  const_iterator			end() const;
  const_reverse_iterator		rbegin() const;
  const_reverse_iterator		rend() const;
  // capacity:
  size_type				size() const;
  size_type				num_elements() const;
  size_type				num_dimensions() const;
 
  // element access:
  template <typename IndexList>
    const element&		operator()(const IndexList& indices) const;
  const_reference		operator[](index i) const;
  const_array_view<Dims>::type	operator[](const indices_tuple& r) const;
  // queries
  const element*		data() const;
  const element*		origin() const;
  const size_type*		shape() const;
  const index*			strides() const;
  const index*			index_bases() const;
  const storage_order_type&     storage_order() const;
  // comparators
  bool operator==(const const_multi_array_ref& rhs);
  bool operator!=(const const_multi_array_ref& rhs);
  bool operator<(const const_multi_array_ref& rhs);
  bool operator>(const const_multi_array_ref& rhs);
  bool operator>=(const const_multi_array_ref& rhs);
  bool operator<=(const const_multi_array_ref& rhs);
  // modifiers:
  template <typename SizeList>
  void			reshape(const SizeList& sizes)
  template <typename BaseList>	void reindex(const BaseList& values);
  void				reindex(index value);
};

Конструкторы.

template <typename ExtentList> explicit const_multi_array_ref(TPtr data, const ExtentList& sizes, const storage_order& store = c_storage_order());

Конструируетconst_multi_array_refс использованием заданных параметров.размерыопределяют форму построенногоconst_multi_array_ref.хранилищеопределяет порядок хранения или компоновку в памяти размеров массива.

ExtentList Requirements. ExtentList must model Collection.

Предпосылки. Размеры.размер() == NumDims

explicit const_multi_array_ref(TPtr data, extent_gen::gen_type<NumDims>::type ranges, const storage_order& store = c_storage_order());

Эффекты. Конструируетconst_multi_array_refс использованием заданных параметров.диапазоныопределяют форму и индексные основания построенного const_multi_array_ref. Это результатNumDimsпривязных вызовов кextent_gen::operator.storeопределяет порядок хранения или компоновку в памяти размеров массива.

const_multi_array_ref(const const_multi_array_ref& x);

Effects. Это создает неглубокую копиюx.

Статья Array Components раздела The Boost C++ Libraries BoostBook Documentation Subset Chapter 25. Boost.MultiArray Reference Manual может быть полезна для разработчиков на c++ и boost.