Последовательный двухсторонний контейнер с линейной памятью - динамический массив любого типа. Подробнее...

#include <pideque.h>

Граф наследования:PIDeque< T >:

Открытые члены
	PIDeque ()
	Создает пустой массив.

	PIDeque (const PIDeque< T > &other)
	Копирующий конструктор.

	PIDeque (std::initializer_list< T > init_list)
	Создает массив из списка инициализации C++11. Подробнее...

	PIDeque (const T *data, size_t size)
	Создает массив из указателя на данные `data` и размер `size`. То есть выделяет память для `size` элементов и копирует данные из указателя `data`.

	PIDeque (size_t pid_size, const T &e=T())
	Создает массив из `size` элементов заполненных `e`.

	PIDeque (size_t piv_size, std::function< T(size_t i)> f)
	Создает массив из `size` элементов созданных функцией `f(size_t i)`. Подробнее...

	PIDeque (PIDeque< T > &&other)
	Перемещающий конструктор.

PIDeque< T > &	operator= (const PIDeque< T > &other)
	Оператор присваивания.

PIDeque< T > &	operator= (PIDeque< T > &&other)
	Оператор перемещающего присваивания.

iterator	begin ()
	Итератор на первый элемент. Подробнее...

iterator	end ()
	Итератор на элемент, следующий за последним элементом. Подробнее...

reverse_iterator	rbegin ()
	Обратный итератор на первый элемент. Подробнее...

reverse_iterator	rend ()
	Обратный итератор на элемент, следующий за последним элементом. Подробнее...

size_t	size () const
	Количество элементов массива. Подробнее...

ssize_t	size_s () const
	Количество элементов массива в виде знакового числа. Подробнее...

size_t	length () const
	Синоним size(). Подробнее...

size_t	capacity () const
	Количество элементов, для которого сейчас выделена память массивом. Подробнее...

bool	isEmpty () const
	Проверяет пуст ли массив. Подробнее...

bool	isNotEmpty () const
	Проверяет не пуст ли массив. Подробнее...

bool	any (std::function< bool(const T &e)> test) const
	Проверяет, удовлетворяет ли какой-либо элемент массива условию, заданному в передаваемой функции `test`. Подробнее...

bool	every (std::function< bool(const T &e)> test) const
	Проверяет, удовлетворяют ли все элементы массива условию, заданному в передаваемой функции `test`. Подробнее...

T &	operator[] (size_t index)
	Полный доступ к элементу по индексу `index`. Подробнее...

const T &	at (size_t index) const
	Доступ исключительно на чтение к элементу по индексу `index`. Подробнее...

const T &	atWhere (std::function< bool(const T &e)> test, ssize_t start=0, const T &def=T()) const
	Возвращает первый элемент массива, проходящего по условию, заданному в передаваемой функции `test`, или `def` если такого элемента нет. Подробнее...

const T &	lastAtWhere (std::function< bool(const T &e)> test, ssize_t start=-1, const T &def=T()) const
	Возвращает последний элемент массива, проходящего по условию, заданному в передаваемой функции `test`, или `def` если такого элемента нет. Подробнее...

T &	back ()
	Последний элемент массива. Подробнее...

T &	front ()
	Первый элемент массива. Подробнее...

bool	operator== (const PIDeque< T > &v) const
	Оператор сравнения с массивом `v`.

bool	operator!= (const PIDeque< T > &v) const
	Оператор сравнения с массивом `v`.

bool	contains (const T &e, ssize_t start=0) const
	Проверяет наличие элемента `e` в массиве. Подробнее...

bool	contains (const PIDeque< T > &v, ssize_t start=0) const
	Проверяет наличие всех элементов `v` в массиве. Подробнее...

int	entries (const T &e, ssize_t start=0) const
	Подсчитывает количество элементов, совпадающих с элементом `e` в массиве. Подробнее...

int	entries (std::function< bool(const T &e)> test, ssize_t start=0) const
	Подсчитывает количество элементов в массиве, проходящих по условию, заданному в передаваемой функции `test`. Подробнее...

ssize_t	indexOf (const T &e, ssize_t start=0) const
	Возвращает первый индекс, по которому данный элемент `e` может быть найден в массиве или `-1`, если такого индекса нет. Подробнее...

ssize_t	indexWhere (std::function< bool(const T &e)> test, ssize_t start=0) const
	Возвращает первый индекс элемента проходящего по условию, заданному в передаваемой функции `test`, или `-1`, если таких элементов нет. Подробнее...

ssize_t	lastIndexOf (const T &e, ssize_t start=-1) const
	Возвращает последний индекс, по которому данный элемент `e` может быть найден в массиве или `-1`, если такого индекса нет. Подробнее...

ssize_t	lastIndexWhere (std::function< bool(const T &e)> test, ssize_t start=-1) const
	Возвращает последний индекс элемента проходящего по условию, заданному в передаваемой функции `test`, или `-1`, если таких элементов нет. Подробнее...

T *	data (size_t index=0)
	Указатель на память массива Подробнее...

const T *	data (size_t index=0) const
	Указатель на память массива только для чтения. Подробнее...

PIDeque< T >	getRange (size_t index, size_t count) const
	Создает подмассив, то есть кусок из текущего массива. Подробнее...

template<typename T1 = T, typename std::enable_if<!std::is_trivially_copyable< T1 >::value, int >::type = 0>
PIDeque< T > &	clear ()
	Очищает массив, удаляет все элементы. Подробнее...

PIDeque< T > &	fill (const T &e=T())
	Заполняет весь массив копиями элемента 'e'. Подробнее...

PIDeque< T > &	fill (std::function< T(size_t i)> f)
	Заполняет весь массив результатом вызова функции 'f(size_t i)'. Подробнее...

PIDeque< T > &	assign (const T &e=T())
	Тоже самое что и fill(). Подробнее...

template<typename T1 = T, typename std::enable_if<!std::is_trivially_copyable< T1 >::value, int >::type = 0>
PIDeque< T > &	assign (size_t new_size, const T &e)
	Сначала делает `resize(new_size)`, затем `fill(e)`. Подробнее...

PIDeque< T > &	resize (size_t new_size, const T &e=T())
	Устанавливает размер массива, новые элементы копируются из `e`. Подробнее...

PIDeque< T > &	resize (size_t new_size, std::function< T(size_t i)> f)
	Устанавливает размер массива, новые элементы создаются функцией `f(size_t i)`. Подробнее...

PIDeque< T > &	reserve (size_t new_size)
	Резервируется память под как минимум `new_size` элементов. Подробнее...

PIDeque< T > &	insert (size_t index, const T &e=T())
	Вставляет значение `e` в позицию `index` в массиве. Подробнее...

PIDeque< T > &	insert (size_t index, T &&e)
	Вставляет значение `e` в позицию `index` в массиве. Подробнее...

PIDeque< T > &	insert (size_t index, const PIDeque< T > &v)
	Вставляет массив `v` в позицию `index` в массиве. Подробнее...

PIDeque< T > &	insert (size_t index, std::initializer_list< T > init_list)
	Вставляет элементы в позицию `index` в массиве. Подробнее...

PIDeque< T > &	remove (size_t index, size_t count=1)
	Удаляет элементы из массива, начиная с позиции `index` в количестве `count`. Подробнее...

void	swap (PIDeque< T > &other)
	Меняет местами массив `v` с этим массивом. Подробнее...

PIDeque< T > &	sort ()
	Сортировка элементов в порядке возрастания. Подробнее...

PIDeque< T > &	sort (std::function< bool(const T &a, const T &b)> comp)
	Сортировка элементов в порядке возрастания. Подробнее...

PIDeque< T > &	reverse ()
	Обращает порядок следования элементов этого массива. Подробнее...

PIDeque< T >	reversed () const
	Возвращает перевернутый массив. Подробнее...

PIDeque< T > &	enlarge (ssize_t add_size, const T &e=T())
	Увеличивает или уменьшает размер массива на `add_size` элементов. Подробнее...

PIDeque< T > &	removeOne (const T &e)
	Удаляет первый элемент, который равен элементу `e`. Подробнее...

PIDeque< T > &	removeAll (const T &e)
	Удаляет все элементы, равные элементу `e`. Подробнее...

PIDeque< T > &	removeWhere (std::function< bool(const T &e)> test)
	Удаляет все элементы, удовлетворяющие условию, заданному в передаваемой функции `test`. Подробнее...

PIDeque< T > &	push_back (const T &e)
	Добавляет элемент `e` в конец массива. Подробнее...

PIDeque< T > &	push_back (T &&e)
	Добавляет элемент `e` в конец массива. Подробнее...

PIDeque< T > &	push_back (std::initializer_list< T > init_list)
	Добавляет элементы в конец массива. Подробнее...

PIDeque< T > &	push_back (const PIDeque< T > &v)
	Добавляет массив `v` в конец массива. Подробнее...

PIDeque< T > &	append (const T &e)
	Добавляет элемент `e` в конец массива. Подробнее...

PIDeque< T > &	append (T &&e)
	Добавляет элемент `e` в конец массива. Подробнее...

PIDeque< T > &	append (std::initializer_list< T > init_list)
	Добавляет элементы в конец массива. Подробнее...

PIDeque< T > &	append (const PIDeque< T > &v)
	Добавляет массив `v` в конец массива. Подробнее...

PIDeque< T > &	operator<< (const T &e)
	Добавляет элемент `e` в конец массива. Подробнее...

PIDeque< T > &	operator<< (T &&e)
	Добавляет элемент `e` в конец массива. Подробнее...

PIDeque< T > &	operator<< (const PIDeque< T > &v)
	Добавляет массив `v` в конец массива. Подробнее...

PIDeque< T > &	push_front (const T &e)
	Добавляет элемент `e` в начало массива. Подробнее...

PIDeque< T > &	push_front (T &&e)
	Добавляет элемент `e` в начало массива. Подробнее...

PIDeque< T > &	push_front (const PIDeque< T > &v)
	Добавляет массив `v` в начало массива. Подробнее...

PIDeque< T > &	push_front (std::initializer_list< T > init_list)
	Добавляет элементы в начало массива. Подробнее...

PIDeque< T > &	prepend (const T &e)
	Добавляет элемент `e` в начало массива. Подробнее...

PIDeque< T > &	prepend (T &&e)
	Добавляет элемент `e` в начало массива. Подробнее...

PIDeque< T > &	prepend (const PIDeque< T > &v)
	Добавляет массив `v` в начало массива. Подробнее...

PIDeque< T > &	prepend (std::initializer_list< T > init_list)
	Добавляет элементы в начало массива. Подробнее...

PIDeque< T > &	pop_back ()
	Удаляет один элемент с конца массива. Подробнее...

PIDeque< T > &	pop_front ()
	Удаляет один элемент с начала массива. Подробнее...

T	take_back ()
	Удаляет один элемент с начала массива и возвращает его. Подробнее...

T	take_front ()
	Удаляет один элемент с конца массива и возвращает его. Подробнее...

template<typename ST >
PIDeque< ST >	toType () const
	Возвращает конвертированный в другой тип массив. Подробнее...

PIDeque< T >	filter (std::function< bool(const T &e)> test) const
	Возвращает новый массив со всеми элементами, прошедшими проверку, задаваемую в передаваемой функции `bool test(const T & e)`. Подробнее...

PIDeque< T >	filterIndexed (std::function< bool(size_t index, const T &e)> test) const
	Аналогично filter() но с параметром индекса `index` в функции `test`. Подробнее...

PIDeque< T >	filterReverse (std::function< bool(const T &e)> test) const
	Аналогично filter() но от конца до начала (справа на лево). Подробнее...

PIDeque< T >	filterReverseIndexed (std::function< bool(size_t index, const T &e)> test) const
	Аналогично filterReverse() но с параметром индекса `index` в функции `test`. Подробнее...

void	forEach (std::function< void(const T &e)> f) const
	Выполняет функцию `void f(const T & e)` для каждого элемента массива. Подробнее...

PIDeque< T > &	forEach (std::function< void(T &e)> f)
	Выполняет функцию `void f(T & e)` для каждого элемента массива. Подробнее...

void	forEachIndexed (std::function< void(size_t index, const T &e)> f) const
	Аналогично forEach() но с параметром индекса `index` в функции `f`. Подробнее...

PIDeque< T > &	forEachIndexed (std::function< void(size_t index, T &e)> f)
	Аналогично forEachIndexed(), но позволяет изменять элементы массива. Подробнее...

void	forEachReverse (std::function< void(const T &e)> f) const
	Аналогично forEach() но от конца до начала (справа на лево). Подробнее...

PIDeque< T > &	forEachReverse (std::function< void(T &e)> f)
	Аналогично forEachReverse(), но позволяет изменять элементы массива. Подробнее...

void	forEachReverseIndexed (std::function< void(size_t index, const T &e)> f) const
	Аналогично forEachIndexed() но от конца до начала (справа на лево). Подробнее...

PIDeque< T > &	forEachReverseIndexed (std::function< void(size_t index, T &e)> f)
	Аналогично forEachReverseIndexed(), но позволяет изменять элементы массива. Подробнее...

template<typename ST >
PIDeque< ST >	map (std::function< ST(const T &e)> f) const
	Создаёт новый массив с результатом вызова указанной функции `ST f(const T & e)` для каждого элемента массива. Подробнее...

template<typename ST >
PIDeque< ST >	mapIndexed (std::function< ST(size_t index, const T &e)> f) const
	Аналогично map() но с параметром индекса `index` в функции `f`. Подробнее...

template<typename ST >
PIDeque< ST >	mapReverse (std::function< ST(const T &e)> f) const
	Аналогично map() но от конца до начала (справа на лево). Подробнее...

template<typename ST >
PIDeque< ST >	mapReverseIndexed (std::function< ST(size_t index, const T &e)> f) const
	Аналогично mapReverse() но с параметром индекса `index` в функции `f`. Подробнее...

template<typename ST >
ST	reduce (std::function< ST(const T &e, const ST &acc)> f, const ST &initial=ST()) const
	Применяет функцию `ST f(const T & e, const ST & acc)` к каждому элементу массива (слева-направо), возвращает одно значение. Подробнее...

template<typename ST >
ST	reduceIndexed (std::function< ST(size_t index, const T &e, const ST &acc)> f, const ST &initial=ST()) const
	Аналогично reduce() но с параметром индекса `index` в функции `f`. Подробнее...

template<typename ST >
ST	reduceReverse (std::function< ST(const T &e, const ST &acc)> f, const ST &initial=ST()) const
	Аналогично reduce() но от конца до начала (справа на лево). Подробнее...

template<typename ST >
ST	reduceReverseIndexed (std::function< ST(size_t index, const T &e, const ST &acc)> f, const ST &initial=ST()) const
	Аналогично reduceReverse() но с параметром индекса `index` в функции `f`. Подробнее...

PIDeque< PIDeque< T > >	reshape (size_t rows, size_t cols, ReshapeOrder order=ReshapeByRow) const
	Изменяет размерность массива, из одномерного массива создает двухмерный. Подробнее...

template<typename C , typename std::enable_if< std::is_same< T, PIDeque< C > >::value, int >::type = 0>
PIDeque< C >	flatten (ReshapeOrder order=ReshapeByRow) const
	Изменяет размерность массива, из двухмерный массива создает одномерный. Подробнее...

template<typename C , typename std::enable_if< std::is_same< T, PIDeque< C > >::value, int >::type = 0>
PIDeque< PIDeque< C > >	reshape (size_t rows, size_t cols, ReshapeOrder order=ReshapeByRow) const
	Изменяет размерность двухмерного массива. Подробнее...

PIDeque< PIDeque< T > >	split (const T &separator) const
	Разделяет массив на двумерный массив с помощью разделителя`separator`. Подробнее...

PIDeque< PIDeque< T > >	splitBySize (size_t sz) const
	Разделяет массив на двумерный массив по кускам не более чем `sz`. Подробнее...

PIDeque< T >	takeRange (size_t index, size_t count)
	Вырезает подмассив, то есть кусок из текущего массива. Подробнее...

Подробное описание

template<typename T>
class PIDeque< T >

Последовательный двухсторонний контейнер с линейной памятью - динамический массив любого типа.

Элементы хранятся непрерывно, а значит доступны не только через итераторы, но и с помощью смещений для обычных указателей на элементы. Это означает, что указатель на элемент PIDeque может передаваться в любую функцию, ожидающую указатель на элемент массива. Добавить элементы можно с помощью функции append() или insert(), а удалить с помощью remove() или removeOne(), removeWhere(). Изменить размер можно функцией resize() или assign(). Массив индексируется с нуля: первый элемент массива имеет индекс, равный 0, а индекс последнего элемента равен size() - 1. Также для массива доступен набор различных удобных функций, например: indexOf(), contains(), entries(), isEmpty(), isNotEmpty(), every(), any(), forEach(), indexWhere(), getRange(), sort(), map(), reduce(), filter(), flatten(), reshape() и другие.

Память PIDeque обрабатывается автоматически, расширяясь по мере необходимости. PIDeque занимает больше места, чем PIVector, поскольку больше памяти выделяется для обработки будущего роста и с начала и с конца. Таким образом, память для PIDeque требуется выделять не при каждой вставке элемента, а только после исчерпания дополнительной памяти. Общий объём выделенной памяти можно получить с помощью функции capacity().

Выделение памяти обычно является дорогостоящей операцией с точки зрения производительности. Функцию reserve() можно использовать для исключения выделения памяти, если количество элементов известно заранее.

Сложность (эффективность) обычных операций над PIDeque следующая:

Произвольный доступ — постоянная O(1)
Вставка и удаление элементов в конце или начале — амортизированная постоянная O(1)
Вставка и удаление элементов — линейная по расстоянию до конца массива O(n)

См. также: PIVector, PIMap

Конструктор(ы)

◆ PIDeque() [1/2]

template<typename T >

PIDeque< T >::PIDeque ( std::initializer_list< T > init_list )

inline

Создает массив из списка инициализации C++11.

PIDeque <int> v{1,2,3};

piCout << v; // {1, 2, 3}

PIDeque

Последовательный двухсторонний контейнер с линейной памятью - динамический массив любого типа.

Definition: pideque.h:118

piCout

#define piCout

Макрос для условного (piDebug) вывода в PICout(StdOut)

Definition: picout.h:35

◆ PIDeque() [2/2]

template<typename T >

PIDeque< T >::PIDeque	(	size_t	piv_size,
		std::function< T(size_t i)>	f
	)

inline

Создает массив из size элементов созданных функцией f(size_t i).

Позволяет передавать Лямбда-выражения для создания элементов в конструкторе.

PIDeque <int> v(5, [](size_t i){return i*2;});

piCout << v; // {0, 2, 4, 6, 8}

Методы

◆ begin()

template<typename T >

iterator PIDeque< T >::begin ( )

inline

Итератор на первый элемент.

Если массив - пуст, возвращаемый итератор будет равен end().

Возвращает: Итераторы в стиле STL

См. также: end(), rbegin(), rend()

◆ end()

template<typename T >

iterator PIDeque< T >::end ( )

inline

Итератор на элемент, следующий за последним элементом.

Этот элемент существует лишь условно, попытка доступа к нему приведёт к выходу за разрешенную память.

Возвращает: Итераторы в стиле STL

См. также: begin(), rbegin(), rend()

◆ rbegin()

template<typename T >

reverse_iterator PIDeque< T >::rbegin ( )

inline

Обратный итератор на первый элемент.

Итератор для прохода массива в обратном порядке. Указывает на последний элемент. Если массив пустой, то совпадает с итератором rend().

Возвращает: Итераторы в стиле STL

См. также: rend(), begin(), end()

◆ rend()

template<typename T >

reverse_iterator PIDeque< T >::rend ( )

inline

Обратный итератор на элемент, следующий за последним элементом.

Итератор для прохода массива в обратном порядке. Указывает на элемент, предшествующий первому элементу. Этот элемент существует лишь условно, попытка доступа к нему приведёт к выходу за разрешенную память.

Возвращает: Итераторы в стиле STL

См. также: rbegin(), begin(), end()

◆ size()

template<typename T >

size_t PIDeque< T >::size ( ) const

inline

Количество элементов массива.

См. также: size_s(), capacity(), isEmpty(), isNotEmpty(), resize(), reserve()

◆ size_s()

template<typename T >

ssize_t PIDeque< T >::size_s ( ) const

inline

Количество элементов массива в виде знакового числа.

См. также: size(), capacity(), isEmpty(), isNotEmpty(), resize(), reserve()

◆ length()

template<typename T >

size_t PIDeque< T >::length ( ) const

inline

Синоним size().

См. также: size(), size_s(), capacity(), isEmpty(), isNotEmpty(), resize(), reserve()

◆ capacity()

template<typename T >

size_t PIDeque< T >::capacity ( ) const

inline

Количество элементов, для которого сейчас выделена память массивом.

Чтобы узнать фактическое количество элементов используйте функцию size().

См. также: reserve(), size(), size_s()

◆ isEmpty()

template<typename T >

bool PIDeque< T >::isEmpty ( ) const

inline

Проверяет пуст ли массив.

Возвращает: true если массив пуст, false иначе.

См. также: size(), size_s(), isEmpty(), isNotEmpty(), resize(), reserve()

◆ isNotEmpty()

template<typename T >

bool PIDeque< T >::isNotEmpty ( ) const

inline

Проверяет не пуст ли массив.

Возвращает: true если массив не пуст, false иначе.

См. также: size(), size_s(), isEmpty(), isNotEmpty(), resize(), reserve()

◆ any()

template<typename T >

bool PIDeque< T >::any ( std::function< bool(const T &e)> test ) const

inline

Проверяет, удовлетворяет ли какой-либо элемент массива условию, заданному в передаваемой функции test.

Возвращает: true если хотя бы для одного элемента передаваемая функция возвращает true, в остальных случаях false. Метод возвращает false при любом условии для пустого массива.

PIDeque<int> v{1, 2, 8, 9};
piCout << v.any([](int e){return e % 2 == 0;}); // true
piCout << v.any([](int e){return e == 3;});     // false

См. также: every(), contains(), entries(), forEach()

◆ every()

template<typename T >

bool PIDeque< T >::every ( std::function< bool(const T &e)> test ) const

inline

Проверяет, удовлетворяют ли все элементы массива условию, заданному в передаваемой функции test.

Возвращает: true если для всех элементов передаваемая функция возвращает true, в остальных случаях false. Метод возвращает true при любом условии для пустого массива.

PIDeque<int> v{1, 2, 8, 9};
piCout << v.every([](int e){return e % 2 == 0;}); // false
piCout << v.every([](int e){return e > 0;});      // true

См. также: any(), contains(), entries(), forEach()

◆ operator[]()

template<typename T >

T & PIDeque< T >::operator[] ( size_t index )

inline

Полный доступ к элементу по индексу index.

Индекс элемента считается от 0. Индекс элемента должен лежать в пределах от 0 до size()-1. Иначе это приведёт к неопределённому поведению программы и ошибкам памяти.

PIDeque<int> v{1, 2, 8, 9};
piCout << v[2]; // 8
v[2] = 5;
piCout << v; // {1, 2, 5, 9}

См. также: at()

◆ at()

template<typename T >

const T & PIDeque< T >::at ( size_t index ) const

inline

Доступ исключительно на чтение к элементу по индексу index.

Индекс элемента считается от 0. Индекс элемента должен лежать в пределах от 0 до size()-1. Иначе это приведёт к неопределённому поведению программы и ошибкам памяти.

◆ atWhere()

template<typename T >

const T & PIDeque< T >::atWhere	(	std::function< bool(const T &e)>	test,
		ssize_t	start = `0`,
		const T &	def = `T()`
	)		const

inline

Возвращает первый элемент массива, проходящего по условию, заданному в передаваемой функции test, или def если такого элемента нет.

См. также: indexWhere()

◆ lastAtWhere()

template<typename T >

const T & PIDeque< T >::lastAtWhere	(	std::function< bool(const T &e)>	test,
		ssize_t	start = `-1`,
		const T &	def = `T()`
	)		const

inline

Возвращает последний элемент массива, проходящего по условию, заданному в передаваемой функции test, или def если такого элемента нет.

См. также: lastIndexWhere()

◆ back()

template<typename T >

T & PIDeque< T >::back ( )

inline

Последний элемент массива.

Возвращает ссылку на последний элемент в массиве. Эта функция предполагает, что массив не пустой. Иначе это приведёт к неопределённому поведению программы и ошибкам памяти.

◆ front()

template<typename T >

T & PIDeque< T >::front ( )

inline

Первый элемент массива.

Возвращает ссылку на пенрвый элемент в массиве. Эта функция предполагает, что массив не пустой. Иначе это приведёт к неопределённому поведению программы и ошибкам памяти.

◆ contains() [1/2]

template<typename T >

bool PIDeque< T >::contains	(	const T &	e,
		ssize_t	start = `0`
	)		const

inline

Проверяет наличие элемента e в массиве.

Опциональный аргумент start указывает на индекс в массиве, откуда будет начинаться поиск. Если индекс больше или равен длине массива, возвращается false, что означает, что массив даже не просматривается. Если индекс является отрицательным числом, он трактуется как смещение с конца массива. Если рассчитанный индекс все равно оказывается меньше 0, просматривается весь массив. Обратите внимание: если индекс отрицателен, массив всё равно просматривается от начала к концу (слева на право). Значение по умолчанию равно 0, что означает, что просматривается весь массив.

PIDeque<int> v{1, 2, 3, 4};
piCout << v.contains(3);      // true
piCout << v.contains(5);      // false
piCout << v.contains(3, 3);   // false
piCout << v.contains(3, -2);  // true
piCout << v.contains(3, -99); // true

Возвращает: true если элемент e присутствует в массиве, в остальных случаях false.

См. также: every(), any(), entries(), forEach()

◆ contains() [2/2]

template<typename T >

bool PIDeque< T >::contains	(	const PIDeque< T > &	v,
		ssize_t	start = `0`
	)		const

inline

Проверяет наличие всех элементов v в массиве.

PIDeque<int> v{1, 2, 3, 4};
piCout << v.contains({1,4}); // true
piCout << v.contains({1,5}); // false

См. также: every(), any(), entries(), forEach()

◆ entries() [1/2]

template<typename T >

int PIDeque< T >::entries	(	const T &	e,
		ssize_t	start = `0`
	)		const

inline

Подсчитывает количество элементов, совпадающих с элементом e в массиве.

Опциональный аргумент start указывает на индекс в массиве, откуда будет начинаться поиск. Если индекс больше или равен длине массива, возвращается 0, что означает, что массив даже не просматривается. Если индекс является отрицательным числом, он трактуется как смещение с конца массива. Если рассчитанный индекс все равно оказывается меньше 0, просматривается весь массив. Обратите внимание: если индекс отрицателен, массив всё равно просматривается от начала к концу (слева на право). Значение по умолчанию равно 0, что означает, что просматривается весь массив.

PIDeque<int> v{2, 2, 4, 2, 6};
piCout << v.entries(2);     // 3
piCout << v.entries(2, 2);  // 1
piCout << v.entries(2, -4); // 2

См. также: every(), any(), contains(), forEach(), indexOf()

◆ entries() [2/2]

template<typename T >

int PIDeque< T >::entries	(	std::function< bool(const T &e)>	test,
		ssize_t	start = `0`
	)		const

inline

Подсчитывает количество элементов в массиве, проходящих по условию, заданному в передаваемой функции test.

Перегруженная функция. Опциональный аргумент start указывает на индекс в массиве, откуда будет начинаться поиск. Если индекс больше или равен длине массива, возвращается 0, что означает, что массив даже не просматривается. Если индекс является отрицательным числом, он трактуется как смещение с конца массива. Если рассчитанный индекс все равно оказывается меньше 0, просматривается весь массив. Обратите внимание: если индекс отрицателен, массив всё равно просматривается от начала к концу (слева на право). Значение по умолчанию равно 0, что означает, что просматривается весь массив.

См. также: every(), any(), contains(), forEach(), indexWhere()

◆ indexOf()

template<typename T >

ssize_t PIDeque< T >::indexOf	(	const T &	e,
		ssize_t	start = `0`
	)		const

inline

Возвращает первый индекс, по которому данный элемент e может быть найден в массиве или -1, если такого индекса нет.

Опциональный аргумент start указывает на индекс в массиве, откуда будет начинаться поиск. Если индекс больше или равен длине массива, возвращается -1, что означает, что массив даже не просматривается. Если индекс является отрицательным числом, он трактуется как смещение с конца массива. Если рассчитанный индекс все равно оказывается меньше 0, просматривается весь массив. Обратите внимание: если индекс отрицателен, массив всё равно просматривается от начала к концу (слева на право). Значение по умолчанию равно 0, что означает, что просматривается весь массив.

PIDeque<int> v{2, 5, 9};
piCout << v.indexOf(2);     // 0
piCout << v.indexOf(7);     // -1
piCout << v.indexOf(9, 2);  // 2
piCout << v.indexOf(2, -1); // -1
piCout << v.indexOf(2, -3); // 0

См. также: indexWhere(), lastIndexOf(), lastIndexWhere(), contains()

◆ indexWhere()

template<typename T >

ssize_t PIDeque< T >::indexWhere	(	std::function< bool(const T &e)>	test,
		ssize_t	start = `0`
	)		const

inline

Возвращает первый индекс элемента проходящего по условию, заданному в передаваемой функции test, или -1, если таких элементов нет.

Опциональный аргумент start указывает на индекс в массиве, откуда будет начинаться поиск. Если индекс больше или равен длине массива, возвращается -1, что означает, что массив даже не просматривается. Если индекс является отрицательным числом, он трактуется как смещение с конца массива. Если рассчитанный индекс все равно оказывается меньше 0, просматривается весь массив. Обратите внимание: если индекс отрицателен, массив всё равно просматривается от начала к концу (слева на право). Значение по умолчанию равно 0, что означает, что просматривается весь массив.

PIDeque<PIString> v{"do", "re", "mi", "re"};
piCout << v.indexWhere([](const PIString & s){return s.startsWith('r');});    // 1
piCout << v.indexWhere([](const PIString & s){return s.startsWith('r');}, 2); // 3
piCout << v.indexWhere([](const PIString & s){return s.startsWith('k');});    // -1

См. также: indexOf(), lastIndexOf(), lastIndexWhere(), contains()

◆ lastIndexOf()

template<typename T >

ssize_t PIDeque< T >::lastIndexOf	(	const T &	e,
		ssize_t	start = `-1`
	)		const

inline

Возвращает последний индекс, по которому данный элемент e может быть найден в массиве или -1, если такого индекса нет.

Опциональный аргумент start указывает на индекс c которого начинать поиск в обратном направлении. Если индекс больше или равен длине массива, просматривается весь массив. Если индекс является отрицательным числом, он трактуется как смещение с конца массива. Обратите внимание: если индекс отрицателен, массив всё равно просматривается от конца к началу (справа на лево). Если рассчитанный индекс оказывается меньше 0, массив даже не просматривается. Значение по умолчанию равно -1, что равно индексу последнего элемента и означает, что просматривается весь массив.

PIDeque<int> v{2, 5, 9, 2};
piCout << v.lastIndexOf(2);       // 3
piCout << v.lastIndexOf(7);       // -1
piCout << v.lastIndexOf(2, 2);    // 0
piCout << v.lastIndexOf(2, -3);   // 0
piCout << v.lastIndexOf(2, -300); // -1
piCout << v.lastIndexOf(2, 300);  // 3

См. также: indexOf(), indexWhere(), lastIndexWhere(), contains()

◆ lastIndexWhere()

template<typename T >

ssize_t PIDeque< T >::lastIndexWhere	(	std::function< bool(const T &e)>	test,
		ssize_t	start = `-1`
	)		const

inline

Возвращает последний индекс элемента проходящего по условию, заданному в передаваемой функции test, или -1, если таких элементов нет.

Опциональный аргумент start указывает на индекс c которого начинать поиск в обратном направлении. Если индекс больше или равен длине массива, просматривается весь массив. Если индекс является отрицательным числом, он трактуется как смещение с конца массива. Обратите внимание: если индекс отрицателен, массив всё равно просматривается от конца к началу (справа на лево). Если рассчитанный индекс оказывается меньше 0, массив даже не просматривается. Значение по умолчанию равно -1, что равно индексу последнего элемента и означает, что просматривается весь массив.

См. также: indexOf(), lastIndexOf(), indexWhere(), contains()

◆ data() [1/2]

template<typename T >

T * PIDeque< T >::data ( size_t index = 0 )

inline

Указатель на память массива

Опциональный аргумент index указывает на индекс c которого брать указатель. По умолчанию указывает на начало массива.

PIDeque<int> v{2, 5, 9, 2};
int a[2] = {12, 13};
memcpy(vec.data(1), a, 2 * sizeof(int));
piCout << v; // {2, 12, 13, 2}

◆ data() [2/2]

template<typename T >

const T * PIDeque< T >::data ( size_t index = 0 ) const

inline

Указатель на память массива только для чтения.

Указатель можно использовать для доступа и изменения элементов в массиве. Указатель остается действительным только до тех пор, пока массив не будет перераспределен. Опциональный аргумент index указывает на индекс c которого брать указатель. По умолчанию указывает на начало массива.

PIDeque<int> v{1, 3, 5};
int a[3];
memcpy(a, v.data(), a.size() * sizeof(int));
piCout << a[0] << a[1] << a[2]; // 1 3 5

◆ getRange()

template<typename T >

PIDeque< T > PIDeque< T >::getRange	(	size_t	index,
		size_t	count
	)		const

inline

Создает подмассив, то есть кусок из текущего массива.

Аргументы

index	- индекс в текущем массиве, откуда начинётся подмассив
count	- размер подмассива

Индекс начала должен лежать в диапазоне от 0 до size()-1. Если заданный размер подмассива превышает размер текущего массива, то вернется подмассив меньшего размера (size()-index-1).

◆ clear()

template<typename T >

template<typename T1 = T, typename std::enable_if<!std::is_trivially_copyable< T1 >::value, int >::type = 0>

PIDeque< T > & PIDeque< T >::clear ( )

inline

Очищает массив, удаляет все элементы.

Заметки: Зарезервированная память не освободится.

См. также: resize()

◆ fill() [1/2]

template<typename T >

PIDeque< T > & PIDeque< T >::fill ( const T & e = T() )

inline

Заполняет весь массив копиями элемента 'e'.

PIDeque<int> v{1, 3, 5};
v.fill(7);
piCout << v; // {7, 7, 7}

См. также: resize()

◆ fill() [2/2]

template<typename T >

PIDeque< T > & PIDeque< T >::fill ( std::function< T(size_t i)> f )

inline

Заполняет весь массив результатом вызова функции 'f(size_t i)'.

PIDeque<int> v{1, 3, 5};
v.fill([](size_t i){return i*2;});
piCout << v; // {0, 2, 4}

См. также: resize()

◆ assign() [1/2]

template<typename T >

PIDeque< T > & PIDeque< T >::assign ( const T & e = T() )

inline

Тоже самое что и fill().

См. также: fill(), resize()

◆ assign() [2/2]

template<typename T >

template<typename T1 = T, typename std::enable_if<!std::is_trivially_copyable< T1 >::value, int >::type = 0>

PIDeque< T > & PIDeque< T >::assign	(	size_t	new_size,
		const T &	e
	)

inline

Сначала делает resize(new_size), затем fill(e).

См. также: fill(), resize()

◆ resize() [1/2]

template<typename T >

PIDeque< T > & PIDeque< T >::resize	(	size_t	new_size,
		const T &	e = `T()`
	)

inline

Устанавливает размер массива, новые элементы копируются из e.

Если new_size больше чем текущий размер массива size(), новые элементы добавляются в конец массива и создаются из e. Если new_size меньше чем текущий размер массива size(), лишние элементы удаляются с конца массива.

См. также: size(), clear()

◆ resize() [2/2]

template<typename T >

PIDeque< T > & PIDeque< T >::resize	(	size_t	new_size,
		std::function< T(size_t i)>	f
	)

inline

Устанавливает размер массива, новые элементы создаются функцией f(size_t i).

Если new_size больше чем текущий размер массива size(), новые элементы добавляются в конец массива и функцией f(size_t i). Если new_size меньше чем текущий размер массива size(), лишние элементы удаляются с конца массива.

См. также: size(), clear()

◆ reserve()

template<typename T >

PIDeque< T > & PIDeque< T >::reserve ( size_t new_size )

inline

Резервируется память под как минимум new_size элементов.

Если вы заранее знаете, насколько велик будет массив, вы можете вызвать эту функцию, чтобы предотвратить перераспределение и фрагментацию памяти. Если размер new_size больше чем выделенная память capacity(), то произойдёт выделение новой памяти и перераспределение массива. Эта функция не изменяет количество элементов в массиве size().

См. также: size(), capacity(), resize()

◆ insert() [1/4]

template<typename T >

PIDeque< T > & PIDeque< T >::insert	(	size_t	index,
		const T &	e = `T()`
	)

inline

Вставляет значение e в позицию index в массиве.

Индекс должен быть больше 0 и меньше или равен size().

PIDeque<int> v{1, 3, 5};
v.insert(2, 7);
piCout << v; // {1, 3, 7, 5}

См. также: append(), prepend(), remove()

◆ insert() [2/4]

template<typename T >

PIDeque< T > & PIDeque< T >::insert	(	size_t	index,
		T &&	e
	)

inline

Вставляет значение e в позицию index в массиве.

Индекс должен быть больше 0 и меньше или равен size().

См. также: append(), prepend(), remove()

◆ insert() [3/4]

template<typename T >

PIDeque< T > & PIDeque< T >::insert	(	size_t	index,
		const PIDeque< T > &	v
	)

inline

Вставляет массив v в позицию index в массиве.

Индекс должен быть больше или равен 0 и меньше или равен size().

См. также: append(), prepend(), remove()

◆ insert() [4/4]

template<typename T >

PIDeque< T > & PIDeque< T >::insert	(	size_t	index,
		std::initializer_list< T >	init_list
	)

inline

Вставляет элементы в позицию index в массиве.

Индекс должен быть больше или равен 0 и меньше или равен size(). Вставляет элементы из списка инициализации C++11.

См. также: append(), prepend(), remove()

◆ remove()

template<typename T >

PIDeque< T > & PIDeque< T >::remove	(	size_t	index,
		size_t	count = `1`
	)

inline

Удаляет элементы из массива, начиная с позиции index в количестве count.

PIDeque<int> v{1, 3, 7, 5};
v.remove(1, 2);
piCout << v; // {1, 5}

См. также: resize(), insert(), removeOne(), removeAll(), removeWhere()

◆ swap()

template<typename T >

void PIDeque< T >::swap ( PIDeque< T > & other )

inline

Меняет местами массив v с этим массивом.

Эта операция выполняется мгновенно без копирования памяти и никогда не дает сбоев.

◆ sort() [1/2]

template<typename T >

PIDeque< T > & PIDeque< T >::sort ( )

inline

Сортировка элементов в порядке возрастания.

Сохранность порядка элементов, имеющих одинаковое значение, не гарантируется. Для сравнения элементов используется оператор operator<. Для сортировки используется функция std::stable_sort. Сложность сортировки O(N·log(N)).

PIDeque<int> v{5, 7, 4, 2, 8, 6, 1, 9, 0, 3};
v.sort();
piCout << v; // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

См. также: sort(std::function<bool(const T &a, const T &b)> comp)

◆ sort() [2/2]

template<typename T >

PIDeque< T > & PIDeque< T >::sort ( std::function< bool(const T &a, const T &b)> comp )

inline

Сортировка элементов в порядке возрастания.

Сохранность порядка элементов, имеющих одинаковое значение, не гарантируется. Для сравнения элементов используется функция сравнения comp. Функция сравнения, возвращает true если первый аргумент меньше второго. Сигнатура функции сравнения должна быть эквивалентна следующей:

bool comp(const T &a, const T &b);

Сигнатура не обязана содержать const &, однако, функция не может изменять переданные объекты. Функция обязана возвращать false для одинаковых элементов, иначе это приведёт к неопределённому поведению программы и ошибкам памяти. Для сортировки используется функция std::stable_sort. Сложность сортировки O(N·log(N)).

PIDeque<int> v{5, 7, 4, 2, 8, 6, 1, 9, 0, 3};
v.sort([](const int & a, const int & b){return a > b;});
piCout << v; // 9, 8, 7, 6, 5, 4, 3, 2, 1, 0

См. также: sort()

◆ reverse()

template<typename T >

PIDeque< T > & PIDeque< T >::reverse ( )

inline

Обращает порядок следования элементов этого массива.

Метод reverse() на месте переставляет элементы массива, на котором он был вызван, изменяет массив и возвращает ссылку на него. Первый элемент массива становится последним, а последний — первым.

PIDeque<int> v{1, 3, 7, 5};
v.reverse();
piCout << v; // {5, 7, 3, 1}

См. также: reversed()

◆ reversed()

template<typename T >

PIDeque< T > PIDeque< T >::reversed ( ) const

inline

Возвращает перевернутый массив.

Возвращает копию массива с элементами в обратном порядке. Первый элемент массива становится последним, а последний — первым.

См. также: reverse()

◆ enlarge()

template<typename T >

PIDeque< T > & PIDeque< T >::enlarge	(	ssize_t	add_size,
		const T &	e = `T()`
	)

inline

Увеличивает или уменьшает размер массива на add_size элементов.

Если add_size > 0, то в конец массива добавляются элементы. Если add_size < 0, то с конца массива удаляются элементы. Если add_size < 0 и в массиве меньше элементов чем указано, то массив становится пустым.

См. также: resize()

◆ removeOne()

template<typename T >

PIDeque< T > & PIDeque< T >::removeOne ( const T & e )

inline

Удаляет первый элемент, который равен элементу e.

PIDeque<int> v{3, 2, 5, 2, 7};
v.removeOne(2);
piCout << v; // {3, 5, 2, 7}

См. также: remove(), removeAll(), removeWhere()

◆ removeAll()

template<typename T >

PIDeque< T > & PIDeque< T >::removeAll ( const T & e )

inline

Удаляет все элементы, равные элементу e.

PIDeque<int> v{3, 2, 5, 2, 7};
v.removeAll(2);
piCout << v; // {3, 5, 7}

См. также: remove(), removeOne(), removeWhere()

◆ removeWhere()

template<typename T >

PIDeque< T > & PIDeque< T >::removeWhere ( std::function< bool(const T &e)> test )

inline

Удаляет все элементы, удовлетворяющие условию, заданному в передаваемой функции test.

PIDeque<int> v{3, 2, 5, 2, 7};
v.removeWhere([](const int & i){return i > 2;});
piCout << v; // {2, 2}

См. также: remove(), removeOne(), removeWhere()

◆ push_back() [1/4]

template<typename T >

PIDeque< T > & PIDeque< T >::push_back ( const T & e )

inline

Добавляет элемент e в конец массива.

Если size() меньше capacity(), что часто бывает, то добавление будет очень быстрым. В любом случае добавление быстрое и не зависит от размера массива. Если новый size() больше, чем capacity(), то все итераторы и указатели становятся нерабочими. В противном случае все, кроме итераторов, указывающих на конец массива, остаются в рабочем состоянии.

PIDeque<int> v{1, 2, 3};
v.push_back(4);
v.push_back(5);
piCout << v; // {1, 2, 3, 4, 5}

См. также: push_front(), append(), prepend(), insert()

◆ push_back() [2/4]

template<typename T >

PIDeque< T > & PIDeque< T >::push_back ( T && e )

inline

Добавляет элемент e в конец массива.

Перегруженая функция.

См. также: push_back()

◆ push_back() [3/4]

template<typename T >

PIDeque< T > & PIDeque< T >::push_back ( std::initializer_list< T > init_list )

inline

Добавляет элементы в конец массива.

Перегруженая функция. Добавляет элементы из списка инициализации C++11.

См. также: push_back()

◆ push_back() [4/4]

template<typename T >

PIDeque< T > & PIDeque< T >::push_back ( const PIDeque< T > & v )

inline

Добавляет массив v в конец массива.

Перегруженая функция.

См. также: push_back()

◆ append() [1/4]

template<typename T >

PIDeque< T > & PIDeque< T >::append ( const T & e )

inline

Добавляет элемент e в конец массива.

Если size() меньше capacity(), что часто бывает, то добавление будет очень быстрым. В любом случае добавление быстрое и не зависит от размера массива. Если новый size() больше, чем capacity(), то все итераторы и указатели становятся нерабочими. В противном случае все, кроме итераторов, указывающих на конец массива, остаются в рабочем состоянии.

PIDeque<int> v{1, 2, 3};
v.append(4);
v.append(5);
piCout << v; // {1, 2, 3, 4, 5}

См. также: prepend(), push_front(), push_back(), insert()

◆ append() [2/4]

template<typename T >

PIDeque< T > & PIDeque< T >::append ( T && e )

inline

Добавляет элемент e в конец массива.

Перегруженая функция.

См. также: append()

◆ append() [3/4]

template<typename T >

PIDeque< T > & PIDeque< T >::append ( std::initializer_list< T > init_list )

inline

Добавляет элементы в конец массива.

Перегруженая функция. Добавляет элементы из списка инициализации C++11.

См. также: append()

◆ append() [4/4]

template<typename T >

PIDeque< T > & PIDeque< T >::append ( const PIDeque< T > & v )

inline

Добавляет массив v в конец массива.

Перегруженая функция.

PIDeque<int> v{1, 2, 3};
v.append(PIDeque<int>{4, 5});
piCout << v; // {1, 2, 3, 4, 5}

См. также: append()

◆ operator<<() [1/3]

template<typename T >

PIDeque< T > & PIDeque< T >::operator<< ( const T & e )

inline

Добавляет элемент e в конец массива.

PIDeque<int> v{1, 2, 3};
v << 4 << 5;
piCout << v; // {1, 2, 3, 4, 5}

См. также: append()

◆ operator<<() [2/3]

template<typename T >

PIDeque< T > & PIDeque< T >::operator<< ( T && e )

inline

Добавляет элемент e в конец массива.

PIDeque<int> v{1, 2, 3};
v << 4 << 5;
piCout << v; // {1, 2, 3, 4, 5}

См. также: append()

◆ operator<<() [3/3]

template<typename T >

PIDeque< T > & PIDeque< T >::operator<< ( const PIDeque< T > & v )

inline

Добавляет массив v в конец массива.

PIDeque<int> v{1, 2, 3};
v << PIDeque<int>{4, 5};
piCout << v; // {1, 2, 3, 4, 5}

См. также: append(), push_back()

◆ push_front() [1/4]

template<typename T >

PIDeque< T > & PIDeque< T >::push_front ( const T & e )

inline

Добавляет элемент e в начало массива.

Если в начале массива имеется свободное место, что часто бывает, то добавление будет очень быстрым. В любом случае добавление быстрое и не зависит от размера массива. Если в начале массива нет свободного места, то все итераторы и указатели становятся нерабочими. В противном случае все, кроме итераторов указывающих, на начало массива, остаются в рабочем состоянии.

PIDeque<int> v{1, 2, 3};
v.push_front(4);
v.push_front(5);
piCout << v; // {5, 4, 1, 2, 3}

См. также: push_back(), append(), prepend(), insert()

◆ push_front() [2/4]

template<typename T >

PIDeque< T > & PIDeque< T >::push_front ( T && e )

inline

Добавляет элемент e в начало массива.

Перегруженая функция.

См. также: push_front()

◆ push_front() [3/4]

template<typename T >

PIDeque< T > & PIDeque< T >::push_front ( const PIDeque< T > & v )

inline

Добавляет массив v в начало массива.

Перегруженая функция.

PIDeque<int> v{1, 2, 3};
v.push_front(PIDeque<int>{4, 5});
piCout << v; // {4, 5, 1, 2, 3}

См. также: push_front()

◆ push_front() [4/4]

template<typename T >

PIDeque< T > & PIDeque< T >::push_front ( std::initializer_list< T > init_list )

inline

Добавляет элементы в начало массива.

Перегруженая функция. Добавляет элементы из списка инициализации C++11.

См. также: append()

◆ prepend() [1/4]

template<typename T >

PIDeque< T > & PIDeque< T >::prepend ( const T & e )

inline

Добавляет элемент e в начало массива.

Если в начале массива имеется свободное место, что часто бывает, то добавление будет очень быстрым. В любом случае добавление быстрое и не зависит от размера массива. Если в начале массива нет свободного места, то все итераторы и указатели становятся нерабочими. В противном случае все, кроме итераторов указывающих, на начало массива, остаются в рабочем состоянии.

PIDeque<int> v{1, 2, 3};
v.prepend(4);
v.prepend(5);
piCout << v; // {5, 4, 1, 2, 3}

См. также: push_back(), append(), prepend(), insert()

◆ prepend() [2/4]

template<typename T >

PIDeque< T > & PIDeque< T >::prepend ( T && e )

inline

Добавляет элемент e в начало массива.

Перегруженая функция.

См. также: prepend()

◆ prepend() [3/4]

template<typename T >

PIDeque< T > & PIDeque< T >::prepend ( const PIDeque< T > & v )

inline

Добавляет массив v в начало массива.

Перегруженая функция.

PIDeque<int> v{1, 2, 3};
v.prepend(PIDeque<int>{4, 5});
piCout << v; // {4, 5, 1, 2, 3}

См. также: prepend()

◆ prepend() [4/4]

template<typename T >

PIDeque< T > & PIDeque< T >::prepend ( std::initializer_list< T > init_list )

inline

Добавляет элементы в начало массива.

Перегруженая функция. Добавляет элементы из списка инициализации C++11.

См. также: append()

◆ pop_back()

template<typename T >

PIDeque< T > & PIDeque< T >::pop_back ( )

inline

Удаляет один элемент с конца массива.

Удаление элемента с конца выполняется очень быстро и не зависит от размера массива.

PIDeque<int> v{1, 2, 3};
v.pop_back();
piCout << v; // {1, 2}

См. также: pop_front(), take_back(), take_front()

◆ pop_front()

template<typename T >

PIDeque< T > & PIDeque< T >::pop_front ( )

inline

Удаляет один элемент с начала массива.

Удаление элемента с начала выполняется дольше, чем с конца. Это время прямопропорционально размеру массива. При удалении элемента все итераторы и указатели становятся нерабочими.

PIDeque<int> v{1, 2, 3};
v.pop_front();
piCout << v; // {2, 3}

См. также: pop_back(), take_back(), take_front()

◆ take_back()

template<typename T >

T PIDeque< T >::take_back ( )

inline

Удаляет один элемент с начала массива и возвращает его.

PIDeque<int> v{1, 2, 3};
piCout << v.take_back(); // 3
piCout << v; // {1, 2}

См. также: take_front(), pop_back(), pop_front()

◆ take_front()

template<typename T >

T PIDeque< T >::take_front ( )

inline

Удаляет один элемент с конца массива и возвращает его.

PIDeque<int> v{1, 2, 3};
piCout << v.take_front(); // 1
piCout << v; // {2, 3}

См. также: take_front(), pop_back(), pop_front()

◆ toType()

template<typename T >

template<typename ST >

PIDeque< ST > PIDeque< T >::toType ( ) const

inline

Возвращает конвертированный в другой тип массив.

PIDeque<double> v{1.1, 2.5, 3.8};
PIDeque<int> v2 = v.toType<int>();
piCout << v2; // {1, 2, 3}

См. также: map()

◆ filter()

template<typename T >

PIDeque< T > PIDeque< T >::filter ( std::function< bool(const T &e)> test ) const

inline

Возвращает новый массив со всеми элементами, прошедшими проверку, задаваемую в передаваемой функции bool test(const T & e).

PIDeque<int> v{3, 2, 5, 2, 7};
PIDeque<int> v2 = v.filter([](const int & i){return i > 2;});
piCout << v2; // {3, 5, 7}

См. также: map(), any(), every()

◆ filterIndexed()

template<typename T >

PIDeque< T > PIDeque< T >::filterIndexed ( std::function< bool(size_t index, const T &e)> test ) const

inline

Аналогично filter() но с параметром индекса index в функции test.

См. также: filter()

◆ filterReverse()

template<typename T >

PIDeque< T > PIDeque< T >::filterReverse ( std::function< bool(const T &e)> test ) const

inline

Аналогично filter() но от конца до начала (справа на лево).

См. также: filter()

◆ filterReverseIndexed()

template<typename T >

PIDeque< T > PIDeque< T >::filterReverseIndexed ( std::function< bool(size_t index, const T &e)> test ) const

inline

Аналогично filterReverse() но с параметром индекса index в функции test.

См. также: filterReverse()

◆ forEach() [1/2]

template<typename T >

void PIDeque< T >::forEach ( std::function< void(const T &e)> f ) const

inline

Выполняет функцию void f(const T & e) для каждого элемента массива.

Не позволяет изменять элементы массива. Для редактирования элементов используйте функцию вида void f(T & e).

PIDeque<int> v{1, 2, 3, 4, 5};
int s = 0;
v.forEach([&s](const int & e){s += e;});
piCout << s; // 15

См. также: filter(), map(), reduce(), any(), every()

◆ forEach() [2/2]

template<typename T >

PIDeque< T > & PIDeque< T >::forEach ( std::function< void(T &e)> f )

inline

Выполняет функцию void f(T & e) для каждого элемента массива.

Перегруженая функция. Позволяет изменять элементы массива.

PIDeque<int> v{1, 2, 3, 4, 5};
v.forEach([](int & e){e++;});
piCout << v; // {2, 3, 4, 5, 6}

См. также: filter(), map(), reduce(), any(), every()

◆ forEachIndexed() [1/2]

template<typename T >

void PIDeque< T >::forEachIndexed ( std::function< void(size_t index, const T &e)> f ) const

inline

Аналогично forEach() но с параметром индекса index в функции f.

См. также: forEach()

◆ forEachIndexed() [2/2]

template<typename T >

PIDeque< T > & PIDeque< T >::forEachIndexed ( std::function< void(size_t index, T &e)> f )

inline

Аналогично forEachIndexed(), но позволяет изменять элементы массива.

См. также: forEach(), forEachIndexed()

◆ forEachReverse() [1/2]

template<typename T >

void PIDeque< T >::forEachReverse ( std::function< void(const T &e)> f ) const

inline

Аналогично forEach() но от конца до начала (справа на лево).

См. также: forEach()

◆ forEachReverse() [2/2]

template<typename T >

PIDeque< T > & PIDeque< T >::forEachReverse ( std::function< void(T &e)> f )

inline

Аналогично forEachReverse(), но позволяет изменять элементы массива.

См. также: forEach(), forEachReverse()

◆ forEachReverseIndexed() [1/2]

template<typename T >

void PIDeque< T >::forEachReverseIndexed ( std::function< void(size_t index, const T &e)> f ) const

inline

Аналогично forEachIndexed() но от конца до начала (справа на лево).

См. также: forEachIndexed(), forEachReverse(), forEach()

◆ forEachReverseIndexed() [2/2]

template<typename T >

PIDeque< T > & PIDeque< T >::forEachReverseIndexed ( std::function< void(size_t index, T &e)> f )

inline

Аналогично forEachReverseIndexed(), но позволяет изменять элементы массива.

См. также: forEachReverseIndexed(), forEachIndexed(), forEachReverse(), forEach()

◆ map()

template<typename T >

template<typename ST >

PIDeque< ST > PIDeque< T >::map ( std::function< ST(const T &e)> f ) const

inline

Создаёт новый массив с результатом вызова указанной функции ST f(const T & e) для каждого элемента массива.

Метод map вызывает переданную функцию ST f(const T & e) один раз для каждого элемента в порядке их появления от начала к концу (слева на право) и конструирует новый массив из результатов её вызова.

PIDeque<int> v{1, 2, 3};
PIStringList sl = v.map<PIString>([](const int & i){return PIString::fromNumber(i);});
piCout << sl; // {"1", "2", "3"}

См. также: forEach(), reduce()

◆ mapIndexed()

template<typename T >

template<typename ST >

PIDeque< ST > PIDeque< T >::mapIndexed ( std::function< ST(size_t index, const T &e)> f ) const

inline

Аналогично map() но с параметром индекса index в функции f.

PIDeque<int> v{1, 2, 3};
PIStringList sl = v.mapIndexed<PIString>([](size_t index, const int & i){return PIString::fromNumber(index);});
piCout << sl; // {"0", "1", "2"}

См. также: map()

◆ mapReverse()

template<typename T >

template<typename ST >

PIDeque< ST > PIDeque< T >::mapReverse ( std::function< ST(const T &e)> f ) const

inline

Аналогично map() но от конца до начала (справа на лево).

PIDeque<int> v{1, 2, 3};
PIStringList sl = v.mapReverse<PIString>([](const int & i){return PIString::fromNumber(i);});
piCout << sl; // {"3", "2", "1"}

См. также: map()

◆ mapReverseIndexed()

template<typename T >

template<typename ST >

PIDeque< ST > PIDeque< T >::mapReverseIndexed ( std::function< ST(size_t index, const T &e)> f ) const

inline

Аналогично mapReverse() но с параметром индекса index в функции f.

PIDeque<int> v{1, 2, 3};
PIStringList sl = v.mapReverseIndexed<PIString>([](size_t index, const int & i){return PIString::fromNumber(index);});
piCout << sl; // {"2", "1", "0"}

См. также: mapReverse()

◆ reduce()

template<typename T >

template<typename ST >

ST PIDeque< T >::reduce	(	std::function< ST(const T &e, const ST &acc)>	f,
		const ST &	initial = `ST()`
	)		const

inline

Применяет функцию ST f(const T & e, const ST & acc) к каждому элементу массива (слева-направо), возвращает одно значение.

Метод reduce() выполняет функцию f один раз для каждого элемента, присутствующего в массиве от начала к концу (слева на право). Если при вызове reduce() передан аргумент initial, то при первом вызове функции f значение acc будет равным значению initial. Если массив пустой то будет возвращено значение initial.

Аргументы

f

Функция, вида ST f(const T & e, const ST & acc), выполняющаяся для каждого элемента массива. Она принимает два аргумента:

e - текущий элемент массива
acc - аккумулятор, аккумулирующий значение которое возвращает эта функция после посещения очередного элемента

initial опциональный Объект, используемый в качестве второго аргумента при первом вызове функции f.

PIDeque<int> v{1, 2, 3, 4, 5};
int s = v.reduce<int>([](const int & e, const int & acc){return e + acc;});
piCout << s; // 15

См. также: reduceIndexed(), reduceReverse(), reduceReverseIndexed(), forEach(), map()

◆ reduceIndexed()

template<typename T >

template<typename ST >

ST PIDeque< T >::reduceIndexed	(	std::function< ST(size_t index, const T &e, const ST &acc)>	f,
		const ST &	initial = `ST()`
	)		const

inline

Аналогично reduce() но с параметром индекса index в функции f.

См. также: reduce()

◆ reduceReverse()

template<typename T >

template<typename ST >

ST PIDeque< T >::reduceReverse	(	std::function< ST(const T &e, const ST &acc)>	f,
		const ST &	initial = `ST()`
	)		const

inline

Аналогично reduce() но от конца до начала (справа на лево).

См. также: reduce()

◆ reduceReverseIndexed()

template<typename T >

template<typename ST >

ST PIDeque< T >::reduceReverseIndexed	(	std::function< ST(size_t index, const T &e, const ST &acc)>	f,
		const ST &	initial = `ST()`
	)		const

inline

Аналогично reduceReverse() но с параметром индекса index в функции f.

См. также: reduceReverse()

◆ reshape() [1/2]

template<typename T >

PIDeque< PIDeque< T > > PIDeque< T >::reshape	(	size_t	rows,
		size_t	cols,
		ReshapeOrder	order = `ReshapeByRow`
	)		const

inline

Изменяет размерность массива, из одномерного массива создает двухмерный.

Аргументы

rows	размер внешнего массива
cols	размер внутренних массивов
order	порядок обхода исходного массива, задаётся с помощью ReshapeOrder PIDeque<int> v{1, 2, 3, 4}; PIDeque<PIDeque<int>> m1 = v.reshape(2,2); piCout << m1; // {{1, 2}, {3, 4}} PIDeque<PIDeque<int>> m2 = v.reshape(2,2, ReshapeByColumn); piCout << m2; // {{1, 3}, {2, 4}} PIDeque::reshape PIDeque< PIDeque< T > > reshape(size_t rows, size_t cols, ReshapeOrder order=ReshapeByRow) const Изменяет размерность массива, из одномерного массива создает двухмерный. Definition: pideque.h:2398 ReshapeByColumn @ ReshapeByColumn Definition: picontainers.h:226

См. также: map(), reduce(), flatten()

◆ flatten()

template<typename T >

template<typename C , typename std::enable_if< std::is_same< T, PIDeque< C > >::value, int >::type = 0>

PIDeque< C > PIDeque< T >::flatten ( ReshapeOrder order = ReshapeByRow ) const

inline

Изменяет размерность массива, из двухмерный массива создает одномерный.

Делает массив плоским. Порядок обхода исходного массива задаётся с помощью ReshapeOrder.

PIDeque<int> v{1, 2, 3, 4, 5, 6};
PIDeque<PIDeque<int>> xv = v.reshape(3,2);
piCout << xv; // {{1, 2}, {3, 4}, {5, 6}}
piCout << xv.flatten<int>(); // {1, 2, 3, 4, 5, 6}

См. также: map(), reduce(), reshape()

◆ reshape() [2/2]

template<typename T >

template<typename C , typename std::enable_if< std::is_same< T, PIDeque< C > >::value, int >::type = 0>

PIDeque< PIDeque< C > > PIDeque< T >::reshape	(	size_t	rows,
		size_t	cols,
		ReshapeOrder	order = `ReshapeByRow`
	)		const

inline

Изменяет размерность двухмерного массива.

Аргументы

rows	размер внешнего массива
cols	размер внутренних массивов
order	порядок обхода исходного массива, задаётся с помощью ReshapeOrder PIDeque<int> v{1, 2, 3, 4, 5, 6}; PIDeque<PIDeque<int>> xv = v.reshape(3,2); piCout << xv; // {{1, 2}, {3, 4}, {5, 6}} piCout << xv.reshape<int>(2,3); // {{1, 2, 3}, {4, 5, 6}}

См. также: map(), reduce(), reshape()

◆ split()

template<typename T >

PIDeque< PIDeque< T > > PIDeque< T >::split ( const T & separator ) const

inline

Разделяет массив на двумерный массив с помощью разделителяseparator.

PIDeque<int> v{1, 2, 3, 99, 4, 5, 99, 6};

piCout << v.split(99); // {{1, 2, 3}, {4, 5}, {6}}

См. также: splitBySize()

◆ splitBySize()

template<typename T >

PIDeque< PIDeque< T > > PIDeque< T >::splitBySize ( size_t sz ) const

inline

Разделяет массив на двумерный массив по кускам не более чем sz.

См. также: split()

◆ takeRange()

template<typename T >

PIDeque< T > PIDeque< T >::takeRange	(	size_t	index,
		size_t	count
	)

inline

Вырезает подмассив, то есть кусок из текущего массива.

Аргументы

index	- индекс в текущем массиве, откуда начинётся подмассив
count	- размер подмассива

Индекс начала должен лежать в диапазоне от 0 до size()-1. Если заданный размер подмассива превышает размер текущего массива, то вернется подмассив меньшего размера (size()-index-1).

Открытые члены

Подробное описание

Конструктор(ы)

◆ PIDeque() [1/2]

◆ PIDeque() [2/2]

Методы

◆ begin()

◆ end()

◆ rbegin()

◆ rend()

◆ size()

◆ size_s()

◆ length()

◆ capacity()

◆ isEmpty()

◆ isNotEmpty()

◆ any()

◆ every()

◆ operator[]()

◆ at()

◆ atWhere()

◆ lastAtWhere()

◆ back()

◆ front()

◆ contains() [1/2]

◆ contains() [2/2]

◆ entries() [1/2]

◆ entries() [2/2]

◆ indexOf()

◆ indexWhere()

◆ lastIndexOf()

◆ lastIndexWhere()

◆ data() [1/2]

◆ data() [2/2]

◆ getRange()

◆ clear()

◆ fill() [1/2]

◆ fill() [2/2]

◆ assign() [1/2]

◆ assign() [2/2]

◆ resize() [1/2]

◆ resize() [2/2]

◆ reserve()

◆ insert() [1/4]

◆ insert() [2/4]

◆ insert() [3/4]

◆ insert() [4/4]

◆ remove()

◆ swap()

◆ sort() [1/2]

◆ sort() [2/2]

◆ reverse()

◆ reversed()

◆ enlarge()

◆ removeOne()

◆ removeAll()

◆ removeWhere()

◆ push_back() [1/4]

◆ push_back() [2/4]

◆ push_back() [3/4]

◆ push_back() [4/4]

◆ append() [1/4]

◆ append() [2/4]

◆ append() [3/4]

◆ append() [4/4]

◆ operator<<() [1/3]

◆ operator<<() [2/3]

◆ operator<<() [3/3]

◆ push_front() [1/4]

◆ push_front() [2/4]

◆ push_front() [3/4]

◆ push_front() [4/4]

◆ prepend() [1/4]

◆ prepend() [2/4]

◆ prepend() [3/4]

◆ prepend() [4/4]

◆ pop_back()

◆ pop_front()

◆ take_back()

◆ take_front()