Класс `deque`

Статья
10/12/2023

Упорядочивает элементы заданного типа в линейном порядке и, подобно векторам, обеспечивает быстрый произвольный доступ к любому элементу и эффективную вставку и удаление в конце контейнера. Однако в отличие от объекта vector класс deque также поддерживает эффективную вставку и удаление в передней части контейнера.

Синтаксис

template <class Type, class Allocator =allocator<Type>>
class deque

Параметры

Type
Тип данных элемента для сохранения в deque.

Allocator
Тип, представляющий хранимый объект распределителя, инкапсулирующий сведения о dequeвыделении и освобождении памяти. Этот аргумент является необязательным, и в качестве значения по умолчанию используется allocator<Type>.

Замечания

Выбор типа контейнера должен в общем случае производиться на основе типа поиска и вставки, который требуется приложению. Vectors должен быть предпочтительным контейнером для управления последовательностью, если случайный доступ к любому элементу находится в категории "Премиум", а вставки или удаления элементов требуются только в конце последовательности. Производительность контейнера list выше, если эффективные вставки и удаления (в константном времени) в любом расположении в последовательности имеют больший приоритет. Таким операциям в середине последовательности требуются копии элементов и присвоения, пропорциональные количеству элементов в последовательности (линейное время).

Deque перемещение происходит, когда функция-член должна вставлять или удалять элементы последовательности:

Если элемент вставляется в пустую последовательность или элемент удаляется, чтобы оставить пустую последовательность, то итераторы, возвращаемые ранее, становятся end недопустимымиbegin.
Если элемент вставляется в первую позицию dequeэлемента, то все итераторы, но нет ссылок, указывающих существующие элементы становятся недействительными.
Если элемент вставляется в конце dequeэлемента, то end и все итераторы, но нет ссылок, которые обозначят существующие элементы, становятся недействительными.
Если элемент удаляется в передней dequeчасти элемента, то только то, что итератор и ссылки на стертый элемент становятся недействительными.
Если последний элемент удаляется из конца deque, то становится недопустимым только тот итератор к последнему элементу и ссылки на стертый элемент.

В противном случае вставка или удаление элемента делает недействительными все итераторы и ссылки.

Участники

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

Имя Описание

deque Создает документ deque. Несколько конструкторов предоставляются для настройки содержимого нового deque по-разному: пустое; загруженное с указанным числом пустых элементов; содержимое перемещается или копируется из другого deque; содержимое копируется или перемещается с помощью итератора; и один элемент, скопированный в время deque count . Некоторые конструкторы позволяют использовать настраиваемый allocator для создания элементов.

Имя	Описание
`deque`	Создает документ `deque`. Несколько конструкторов предоставляются для настройки содержимого нового `deque` по-разному: пустое; загруженное с указанным числом пустых элементов; содержимое перемещается или копируется из другого `deque`; содержимое копируется или перемещается с помощью итератора; и один элемент, скопированный в время `deque` `count` . Некоторые конструкторы позволяют использовать настраиваемый `allocator` для создания элементов.

Определения типов

Имя	Описание
`allocator_type`	Тип, представляющий класс `allocator` для объекта `deque`.
`const_iterator`	Тип, предоставляющий итератор произвольного доступа, который может считывать элементы в `deque` как `const` и обращаться к ним.
`const_pointer`	Тип, предоставляющий указатель на элемент в `deque` виде `const`.
`const_reference`	Тип, предоставляющий ссылку на элемент в элементе для `deque` чтения и других операций как `const`.
`const_reverse_iterator`	Тип, предоставляющий итератор произвольного доступа, который может считывать элементы в `deque` как `const` и обращаться к ним. Объект `deque` просматривается в обратном направлении. Дополнительные сведения см. в разделе `reverse_iterator` "Класс"
`difference_type`	Тип, предоставляющий разницу между двумя итераторами произвольного доступа, ссылающимися на элементы в одном и том же `deque`.
`iterator`	Тип, предоставляющий итератор произвольного доступа, который может считывать или изменять любой элемент в `deque`.
`pointer`	Тип, предоставляющий указатель на элемент в `deque`.
`reference`	Тип, предоставляющий ссылку на элемент, хранящийся в контейнере `deque`.
`reverse_iterator`	Тип, предоставляющий итератор произвольного доступа, который может считывать или изменять элемент в `deque`. Объект `deque` просматривается в обратном порядке.
`size_type`	Тип, считающий количество элементов в `deque`.
`value_type`	Тип, который представляет тип данных, хранящийся в контейнере `deque`.

Функции

Имя	Описание
`assign`	Удаляет элементы из `deque` и копирует новую последовательность элементов в целевой объект `deque`.
`at`	Возвращает ссылку на элемент в заданном положении в `deque`.
`back`	Возвращает ссылку на последний элемент в `deque`.
`begin`	Возвращает итератор произвольного доступа, указывающий на первый элемент в `deque`.
`cbegin`	`const` Возвращает итератор первому элементу в элементе`deque`.
`cend`	Возвращает итератор `const` произвольного доступа, который указывает на позицию, следующую за концом `deque`.
`clear`	Стирает все элементы в `deque`.
`crbegin`	Возвращает итератор случайного доступа `const` к первому элементу в представлении в обратном `deque` порядке.
`crend`	Возвращает итератор случайного доступа `const` к первому элементу в представлении в обратном `deque` порядке.
`emplace`	Вставляет элемент, созданный на месте, в указанное положение в `deque`.
`emplace_back`	Добавляет элемент, созданный на месте, в конец `deque`.
`emplace_front`	Добавляет элемент, созданный на месте, в начало `deque`.
`empty`	Возвращает `true`, если `deque` не содержит элементов, и `false`, если он содержит один или несколько элементов.
`end`	Возвращает итератор произвольного доступа, который указывает на позицию, следующую за концом `deque`.
`erase`	Удаляет элемент или диапазон элементов с указанных позиций в `deque`.
`front`	Возвращает ссылку на первый элемент в `deque`.
`get_allocator`	Возвращает копию объекта `allocator`, который используется для создания `deque`.
`insert`	Вставляет элемент, несколько элементов или диапазон элементов в `deque` в заданной позиции.
`max_size`	Возвращает максимально возможную длину `deque`.
`pop_back`	Удаляет элемент в конце `deque`.
`pop_front`	Удаляет элемент в начале `deque`.
`push_back`	Добавляет элемент в конец `deque`.
`push_front`	Добавляет элемент в начало `deque`.
`rbegin`	Возвращает итератор произвольного доступа, указывающий на первый элемент в обратном `deque`.
`rend`	Возвращает итератор произвольного доступа, указывающий на расположение после последнего элемента в обратном `deque`.
`resize`	Указывает новый размер `deque`.
`shrink_to_fit`	Удаляет лишнюю емкость.
`size`	Возвращает количество элементов в контейнере `deque`.
`swap`	Выполняет обмен элементами между двумя объектами `deque`.

Операторы

Имя	Описание
`operator[]`	Возвращает ссылку на элемент `deque` в указанной позиции.
`operator=`	Заменяет элементы `deque` копией другого `deque`.

`allocator_type`

Тип, представляющий класс распределителя для deque объекта.

typedef Allocator allocator_type;

Замечания

allocator_type является синонимом для параметра-шаблона Allocator.

Пример

Пример см. в примере get_allocator.

`assign`

Удаляет элементы из deque объекта и копирует новый набор элементов в целевой dequeобъект.

template <class InputIterator>
void assign(
    InputIterator First,
    InputIterator Last);

void assign(
    size_type Count,
    const Type& Val);

void assign(initializer_list<Type> IList);

Параметры

First
Позиция первого элемента в диапазоне элементов, скопированных из аргумента deque.

Last
Позиция первого элемента за пределами диапазона элементов, скопированных из аргумента deque.

Count
Число копий элемента, вставленного в объект deque.

Val
Значение элемента, вставляемого в deque.

IList
Вставленный initializer_list в объект deque.

Замечания

После удаления всех существующих элементов в целевом deque объекте вставляет указанный диапазон элементов из исходного deque или другого deque в целевой dequeобъект или вставляет копии нового элемента указанного значения в целевой объектdeque. assign

Пример

// deque_assign.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>
#include <initializer_list>

int main()
{
    using namespace std;
    deque <int> c1, c2;
    deque <int>::const_iterator cIter;

    c1.push_back(10);
    c1.push_back(20);
    c1.push_back(30);
    c2.push_back(40);
    c2.push_back(50);
    c2.push_back(60);

    deque<int> d1{ 1, 2, 3, 4 };
    initializer_list<int> iList{ 5, 6, 7, 8 };
    d1.assign(iList);

    cout << "d1 = ";
    for (int i : d1)
        cout << i;
    cout << endl;

    cout << "c1 =";
    for (int i : c1)
        cout << i;
    cout << endl;

    c1.assign(++c2.begin(), c2.end());
    cout << "c1 =";
    for (int i : c1)
        cout << i;
    cout << endl;

    c1.assign(7, 4);
    cout << "c1 =";
    for (int i : c1)
        cout << i;
    cout << endl;
}

d1 = 5678c1 =102030c1 =5060c1 =4444444

`at`

Возвращает ссылку на элемент в заданном положении в deque.

reference at(size_type pos);

const_reference at(size_type pos) const;

Параметры

pos
Подстрочный (или номер позиции) элемента, на который будет ссылаться в элементе deque.

Возвращаемое значение

Если pos размер больше размера deque, at вызывает исключение.

Замечания

Если возвращаемое значение at назначено объекту const_reference, deque объект нельзя изменить. Если возвращаемое значение at назначено объекту reference, deque объект можно изменить.

Пример

// deque_at.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 20 );

   const int& i = c1.at( 0 );
   int& j = c1.at( 1 );
   cout << "The first element is " << i << endl;
   cout << "The second element is " << j << endl;
}

The first element is 10
The second element is 20

`back`

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

reference back();
const_reference back() const;

Возвращаемое значение

Последний элемент dequeэлемента . Если значение deque пусто, возвращаемое значение не определено.

Замечания

Если возвращаемое значение back назначено объекту const_reference, deque объект нельзя изменить. Если возвращаемое значение back назначено объекту reference, deque объект можно изменить.

При компиляции с помощью _ITERATOR_DEBUG_LEVEL определенного значения 1 или 2 при попытке получить доступ к элементу в пустом dequeвиде возникнет ошибка среды выполнения. Дополнительные сведения см. в разделе Checked Iterators .

Пример

// deque_back.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 11 );

   int& i = c1.back( );
   const int& ii = c1.front( );

   cout << "The last integer of c1 is " << i << endl;
   i--;
   cout << "The next-to-last integer of c1 is " << ii << endl;
}

The last integer of c1 is 11
The next-to-last integer of c1 is 10

`begin`

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

const_iterator begin() const;
iterator begin();

Возвращаемое значение

Итератор произвольного доступа, который указывает на первый элемент в deque или на элемент, следующий за пустым deque.

Замечания

Если возвращаемое значение begin назначено объекту const_iterator, deque объект нельзя изменить. Если возвращаемое значение begin назначено объекту iterator, deque объект можно изменить.

Пример

// deque_begin.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::iterator c1_Iter;
   deque <int>::const_iterator c1_cIter;

   c1.push_back( 1 );
   c1.push_back( 2 );

   c1_Iter = c1.begin( );
   cout << "The first element of c1 is " << *c1_Iter << endl;

*c1_Iter = 20;
   c1_Iter = c1.begin( );
   cout << "The first element of c1 is now " << *c1_Iter << endl;

   // The following line would be an error because iterator is const
   // *c1_cIter = 200;
}

The first element of c1 is 1
The first element of c1 is now 20

`cbegin`

Возвращает итератор const, направленный на первый элемент в диапазоне.

const_iterator cbegin() const;

Возвращаемое значение

Итератор случайного доступа const, который указывает на первый элемент диапазона или расположение прямо за концом пустого диапазона (cbegin() == cend() для пустого диапазона).

Замечания

При возвращаемом значении cbeginэлементы в диапазоне не могут быть изменены.

Эту функцию-член можно использовать вместо функции-члена begin(), чтобы гарантировать, что возвращаемое значение будет const_iterator. Как правило, он используется в сочетании с ключевым словом вычета auto типов, как показано в следующем примере. В примере Container следует рассматривать как изменяемый (не-const) контейнер любого вида, который поддерживает begin() и cbegin().

auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();

// i2 is Container<T>::const_iterator

`cend`

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

const_iterator cend() const;

Возвращаемое значение

Итератор с произвольным доступом, который указывает конец диапазона.

Замечания

cend используется для проверки того, прошел ли итератор конец диапазона.

Эту функцию-член можно использовать вместо функции-члена end(), чтобы гарантировать, что возвращаемое значение будет const_iterator. Как правило, он используется в сочетании с ключевым словом вычета auto типов, как показано в следующем примере. В примере Container следует рассматривать как изменяемый (не-const) контейнер любого вида, который поддерживает end() и cend().

auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();

// i2 is Container<T>::const_iterator

Возвращаемое cend значение не должно быть разоменовывано.

`clear`

Стирает все элементы в deque.

void clear();

Пример

// deque_clear.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );

   cout << "The size of the deque is initially " << c1.size( ) << endl;
   c1.clear( );
   cout << "The size of the deque after clearing is " << c1.size( ) << endl;
}

The size of the deque is initially 3
The size of the deque after clearing is 0

`const_iterator`

Тип, предоставляющий итератор случайного доступа, который может получить доступ к элементу const и считывать его.deque

typedef implementation-defined const_iterator;

Замечания

Тип const_iterator нельзя использовать для изменения значения элемента.

Пример

Пример см. в примере back.

`const_pointer`

Предоставляет указатель на const элемент в элементе deque.

typedef typename Allocator::const_pointer const_pointer;

Замечания

Тип const_pointer нельзя использовать для изменения значения элемента. Чаще iterator используется для доступа к элементу deque .

`const_reference`

Тип, предоставляющий ссылку на элемент const, сохраненный в контейнере deque для чтения и выполнения операций const.

typedef typename Allocator::const_reference const_reference;

Замечания

Тип const_reference нельзя использовать для изменения значения элемента.

Пример

// deque_const_ref.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 20 );

   const deque <int> c2 = c1;
   const int &i = c2.front( );
   const int &j = c2.back( );
   cout << "The first element is " << i << endl;
   cout << "The second element is " << j << endl;

   // The following line would cause an error as c2 is const
   // c2.push_back( 30 );
}

The first element is 10
The second element is 20

`const_reverse_iterator`

Тип, предоставляющий итератор случайного доступа, который может считывать любой const элемент в элементе deque.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Замечания

Тип const_reverse_iterator не может изменить значение элемента и используется для итерации с помощью обратного deque элемента.

Пример

Пример объявления и использования итератора см. в примере rbegin .

`crbegin`

const Возвращает итератор первому элементу в обратном dequeпорядке.

const_reverse_iterator crbegin() const;

Возвращаемое значение

Обратный const итератор случайного доступа, обращаюющийся к первому элементу в обратном deque или адресу, который был последним элементом в непровернутом deque.

Замечания

Возвращаемое значение crbegindeque объекта невозможно изменить.

Пример

// deque_crbegin.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> v1;
   deque <int>::iterator v1_Iter;
   deque <int>::const_reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   v1_Iter = v1.begin( );
   cout << "The first element of deque is "
        << *v1_Iter << "." << endl;

   v1_rIter = v1.crbegin( );
   cout << "The first element of the reversed deque is "
        << *v1_rIter << "." << endl;
}

The first element of deque is 1.
The first element of the reversed deque is 2.

`crend`

const Возвращает итератор, который обращается к расположению, успешному последнему элементу в обратномdeque.

const_reverse_iterator crend() const;

Возвращаемое значение

const Обратный итератор случайного доступа, который обращается к расположению, успешному последнему элементу в обратном deque направлении (расположение, которое предшествовало первому элементу в непровернутомdeque).

Замечания

crend используется с обратным deque так же, как array::cend используется с deque.

Возвращаемое значение crend (подходящее уменьшение), deque объект не может быть изменен.

crend используется, чтобы проверить, достиг ли итератор конца deque.

Возвращаемое crend значение не должно быть разоменовывано.

Пример

// deque_crend.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> v1;
   deque <int>::const_reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   for ( v1_rIter = v1.rbegin( ) ; v1_rIter != v1.rend( ) ; v1_rIter++ )
      cout << *v1_rIter << endl;
}

2
1

`deque`

deque Создает определенный размер или элементы определенного значения или с определенным распределителем или как копию всех или частью другогоdeque.

deque();

explicit deque(const Allocator& Al);
explicit deque(size_type Count);
deque(size_type Count, const Type& Val);

deque(
    size_type Count,
    const Type& Val,
    const Allocator& Al);

deque(const deque& Right);

template <class InputIterator>
deque(InputIterator First,  InputIterator Last);

template <class InputIterator>
deque(
   InputIterator First,
   InputIterator Last,
   const Allocator& Al);

deque(initializer_list<value_type> IList, const Allocator& Al);

Параметры

Al
Класс распределителя для использования с данным объектом.

Count
Количество элементов в построенном dequeобъекте.

Val
Значение элементов в построенном dequeобъекте.

Right
deque, копией которого будет создаваемый deque.

First
Положение первого элемента в диапазоне копируемых элементов.

Last
Положение первого элемента за пределами диапазона копируемых элементов.

IList
Копируемый объект initializer_list.

Замечания

Все конструкторы хранят объект распределителя (Al) и инициализировать dequeобъект .

Первые два конструктора указывают пустой инициал deque; второй также указывает тип распределителя (_Al) для использования.

Третий конструктор задает повторение указанного числа (count) элементов со значением по умолчанию для класса Type.

Четвертый и пятый конструкторы указывают повторение (Count) элементов значения val.

Шестой конструктор указывает копию deque Right.

Седьмой и восьмой конструкторы копируют диапазон [First, Last) deque.

Седьмой конструктор перемещает deque Right.

Восьмой конструктор копирует содержимое объекта initializer_list.

Ни один из конструкторов не выполняет промежуточные перераспределения.

Пример

/ compile with: /EHsc
#include <deque>
#include <iostream>
#include <forward_list>

int main()
{
    using namespace std;

    forward_list<int> f1{ 1, 2, 3, 4 };

    f1.insert_after(f1.begin(), { 5, 6, 7, 8 });

    deque <int>::iterator c1_Iter, c2_Iter, c3_Iter, c4_Iter, c5_Iter, c6_Iter;

    // Create an empty deque c0
    deque <int> c0;

    // Create a deque c1 with 3 elements of default value 0
    deque <int> c1(3);

    // Create a deque c2 with 5 elements of value 2
    deque <int> c2(5, 2);

    // Create a deque c3 with 3 elements of value 1 and with the
    // allocator of deque c2
    deque <int> c3(3, 1, c2.get_allocator());

    // Create a copy, deque c4, of deque c2
    deque <int> c4(c2);

    // Create a deque c5 by copying the range c4[ first,  last)
    c4_Iter = c4.begin();
    c4_Iter++;
    c4_Iter++;
    deque <int> c5(c4.begin(), c4_Iter);

    // Create a deque c6 by copying the range c4[ first,  last) and
    // c2 with the allocator of deque
    c4_Iter = c4.begin();
    c4_Iter++;
    c4_Iter++;
    c4_Iter++;
    deque <int> c6(c4.begin(), c4_Iter, c2.get_allocator());

    // Create a deque c8 by copying the contents of an initializer_list
    // using brace initialization
    deque<int> c8({ 1, 2, 3, 4 });

    initializer_list<int> iList{ 5, 6, 7, 8 };
    deque<int> c9( iList);

    cout << "c1 = ";
    for (int i : c1)
        cout << i << " ";
    cout << endl;

    cout << "c2 = ";
    for (int i : c2)
        cout << i << " ";
    cout << endl;

    cout << "c3 = ";
    for (int i : c3)
        cout << i << " ";
    cout << endl;

    cout << "c4 = ";
    for (int i : c4)
        cout << i << " ";
    cout << endl;

    cout << "c5 = ";
    for (int i : c5)
        cout << i << " ";
    cout << endl;

    cout << "c6 = ";
    for (int i : c6)
        cout << i << " ";
    cout << endl;

    // Move deque c6 to deque c7
    deque <int> c7(move(c6));
    deque <int>::iterator c7_Iter;

    cout << "c7 =";
    for (int i : c7)
        cout << i << " ";
    cout << endl;

    cout << "c8 = ";
    for (int i : c8)
        cout << i << " ";
    cout << endl;

    cout << "c9 = ";
    for (int i : c9)
        cout << i << " ";
    cout << endl;

    int x = 3;
}
// deque_deque.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
    using namespace std;
   deque <int>::iterator c1_Iter, c2_Iter, c3_Iter, c4_Iter, c5_Iter, c6_Iter;

    // Create an empty deque c0
    deque <int> c0;

    // Create a deque c1 with 3 elements of default value 0
    deque <int> c1( 3 );

    // Create a deque c2 with 5 elements of value 2
    deque <int> c2( 5, 2 );

    // Create a deque c3 with 3 elements of value 1 and with the
    // allocator of deque c2
    deque <int> c3( 3, 1, c2.get_allocator( ) );

    // Create a copy, deque c4, of deque c2
    deque <int> c4( c2 );

    // Create a deque c5 by copying the range c4[ first,  last)
    c4_Iter = c4.begin( );
    c4_Iter++;
    c4_Iter++;
    deque <int> c5( c4.begin( ), c4_Iter );

    // Create a deque c6 by copying the range c4[ first,  last) and
    // c2 with the allocator of deque
    c4_Iter = c4.begin( );
   c4_Iter++;
   c4_Iter++;
   c4_Iter++;
   deque <int> c6( c4.begin( ), c4_Iter, c2.get_allocator( ) );

    // Create a deque c8 by copying the contents of an initializer_list
    // using brace initialization
    deque<int> c8({ 1, 2, 3, 4 });

        initializer_list<int> iList{ 5, 6, 7, 8 };
    deque<int> c9( iList);

    cout << "c1 = ";
    for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
        cout << *c1_Iter << " ";
    cout << endl;

    cout << "c2 = ";
    for ( c2_Iter = c2.begin( ); c2_Iter != c2.end( ); c2_Iter++ )
        cout << *c2_Iter << " ";
    cout << endl;

    cout << "c3 = ";
    for ( c3_Iter = c3.begin( ); c3_Iter != c3.end( ); c3_Iter++ )
        cout << *c3_Iter << " ";
    cout << endl;

    cout << "c4 = ";
    for ( c4_Iter = c4.begin( ); c4_Iter != c4.end( ); c4_Iter++ )
        cout << *c4_Iter << " ";
    cout << endl;

    cout << "c5 = ";
    for ( c5_Iter = c5.begin( ); c5_Iter != c5.end( ); c5_Iter++ )
        cout << *c5_Iter << " ";
    cout << endl;

    cout << "c6 = ";
    for ( c6_Iter = c6.begin( ); c6_Iter != c6.end( ); c6_Iter++ )
        cout << *c6_Iter << " ";
    cout << endl;

    // Move deque c6 to deque c7
    deque <int> c7( move(c6) );
    deque <int>::iterator c7_Iter;

    cout << "c7 =" ;
    for ( c7_Iter = c7.begin( ) ; c7_Iter != c7.end( ) ; c7_Iter++ )
        cout << " " << *c7_Iter;
    cout << endl;

    cout << "c8 = ";
    for (int i : c8)
        cout << i << " ";
    cout << endl;

    cout << "c9 = ";
    or (int i : c9)
        cout << i << " ";
    cout << endl;
}

`difference_type`

Тип, который предоставляет различие между 2 итераторами, относящимися к элементам в одном контейнере deque.

typedef typename Allocator::difference_type difference_type;

Замечания

difference_type также можно описать как число элементов между двумя указателями.

Пример

// deque_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <deque>
#include <algorithm>

int main( )
{
   using namespace std;

   deque <int> c1;
   deque <int>::iterator c1_Iter, c2_Iter;

   c1.push_back( 30 );
   c1.push_back( 20 );
   c1.push_back( 30 );
   c1.push_back( 10 );
   c1.push_back( 30 );
   c1.push_back( 20 );

   c1_Iter = c1.begin( );
   c2_Iter = c1.end( );

   deque <int>::difference_type df_typ1, df_typ2, df_typ3;

   df_typ1 = count( c1_Iter, c2_Iter, 10 );
   df_typ2 = count( c1_Iter, c2_Iter, 20 );
   df_typ3 = count( c1_Iter, c2_Iter, 30 );
   cout << "The number '10' is in c1 collection " << df_typ1 << " times.\n";
   cout << "The number '20' is in c1 collection " << df_typ2 << " times.\n";
   cout << "The number '30' is in c1 collection " << df_typ3 << " times.\n";
}

The number '10' is in c1 collection 1 times.
The number '20' is in c1 collection 2 times.
The number '30' is in c1 collection 3 times.

`emplace`

Вставляет элемент, созданный на месте, в указанное положение в deque.

iterator emplace(
    const_iterator _Where,
    Type&& val);

Параметры

_Where
Позиция в deque месте вставки первого элемента.

val
Значение элемента, вставляемого в deque.

Возвращаемое значение

Функция возвращают итератор, указывающий на положение вставки нового элемента в deque.

Замечания

Любая операция вставки может быть ресурсоемкой. Факторы производительности при работе с объектом deque рассматриваются в разделе deque.

Пример

// deque_emplace.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> v1;
   deque <int>::iterator Iter;

   v1.push_back( 10 );
   v1.push_back( 20 );
   v1.push_back( 30 );

   cout << "v1 =" ;
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

// initialize a deque of deques by moving v1
   deque < deque <int> > vv1;

   vv1.emplace( vv1.begin(), move( v1 ) );
   if ( vv1.size( ) != 0 && vv1[0].size( ) != 0 )
      {
      cout << "vv1[0] =";
      for (Iter = vv1[0].begin( ); Iter != vv1[0].end( ); Iter++ )
         cout << " " << *Iter;
      cout << endl;
      }
}

v1 = 10 20 30
vv1[0] = 10 20 30

`emplace_back`

Добавляет элемент, созданный на месте, в конец deque.

void emplace_back(Type&& val);

Параметры

val
Элемент, добавляемый в конец deque.

Пример

// deque_emplace_back.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> v1;

   v1.push_back( 1 );
   if ( v1.size( ) != 0 )
      cout << "Last element: " << v1.back( ) << endl;

   v1.push_back( 2 );
   if ( v1.size( ) != 0 )
      cout << "New last element: " << v1.back( ) << endl;

// initialize a deque of deques by moving v1
   deque < deque <int> > vv1;

   vv1.emplace_back( move( v1 ) );
   if ( vv1.size( ) != 0 && vv1[0].size( ) != 0 )
      cout << "Moved last element: " << vv1[0].back( ) << endl;
}

Last element: 1
New last element: 2
Moved last element: 2

`emplace_front`

Добавляет элемент, созданный на месте, в конец deque.

void emplace_front(Type&& val);

Параметры

val
Элемент, добавленный в начало dequeэлемента .

Пример

// deque_emplace_front.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> v1;

   v1.push_back( 1 );
   if ( v1.size( ) != 0 )
      cout << "Last element: " << v1.back( ) << endl;

   v1.push_back( 2 );
   if ( v1.size( ) != 0 )
      cout << "New last element: " << v1.back( ) << endl;

// initialize a deque of deques by moving v1
   deque < deque <int> > vv1;

   vv1.emplace_front( move( v1 ) );
   if ( vv1.size( ) != 0 && vv1[0].size( ) != 0 )
      cout << "Moved last element: " << vv1[0].back( ) << endl;
}

Last element: 1
New last element: 2
Moved last element: 2

`empty`

Проверяет, пуст ли deque.

bool empty() const;

Возвращаемое значение

truedeque Значение , если deque значение не является пустымfalse.

Пример

// deque_empty.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   if ( c1.empty( ) )
      cout << "The deque is empty." << endl;
   else
      cout << "The deque is not empty." << endl;
}

The deque is not empty.

`end`

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

const_iterator end() const;

iterator end();

Возвращаемое значение

Итератор случайного доступа, который обращается к расположению, успешному последнему элементу в объекте deque. Если deque является пустым, то deque::end == deque::begin.

Замечания

end используется для проверки, достиг ли итератор конца своего deque.

Пример

// deque_end.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::iterator c1_Iter;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );

   c1_Iter = c1.end( );
   c1_Iter--;
   cout << "The last integer of c1 is " << *c1_Iter << endl;

   c1_Iter--;
   *c1_Iter = 400;
   cout << "The new next-to-last integer of c1 is " << *c1_Iter << endl;

   // If a const iterator had been declared instead with the line:
   // deque <int>::const_iterator c1_Iter;
   // an error would have resulted when inserting the 400

   cout << "The deque is now:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
}

The last integer of c1 is 30
The new next-to-last integer of c1 is 400
The deque is now: 10 400 30

`erase`

Удаляет элемент или диапазон элементов с указанных позиций в deque.

iterator erase(iterator _Where);

iterator erase(iterator first, iterator last);

Параметры

_Where
Положение элемента, который необходимо удалить из dequeэлемента.

first
Позиция первого элемента, удаленного из элемента deque.

last
Позиция только за последним элементом, удаленным из элемента deque.

Возвращаемое значение

Итератор случайного доступа, указывающий первый элемент, оставшийся за пределами удаленных элементов, или указатель на конец deque элемента, если такой элемент не существует.

Замечания

erase никогда не создает исключений.

Пример

// deque_erase.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::iterator Iter;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );
   c1.push_back( 40 );
   c1.push_back( 50 );
   cout << "The initial deque is: ";
   for ( Iter = c1.begin( ); Iter != c1.end( ); Iter++ )
      cout << *Iter << " ";
   cout << endl;
   c1.erase( c1.begin( ) );
   cout << "After erasing the first element, the deque becomes:  ";
   for ( Iter = c1.begin( ); Iter != c1.end( ); Iter++ )
      cout << *Iter << " ";
   cout << endl;
   Iter = c1.begin( );
   Iter++;
   c1.erase( Iter, c1.end( ) );
   cout << "After erasing all elements but the first, deque becomes: ";
   for ( Iter = c1.begin( ); Iter != c1.end( ); Iter++ )
      cout << *Iter << " ";
   cout << endl;
}

The initial deque is: 10 20 30 40 50
After erasing the first element, the deque becomes:  20 30 40 50
After erasing all elements but the first, deque becomes: 20

`front`

Возвращает ссылку на первый элемент в deque.

reference front();

const_reference front() const;

Возвращаемое значение

Если значение deque пусто, возврат не определен.

Замечания

Если возвращаемое значение front назначено объекту const_reference, deque объект нельзя изменить. Если возвращаемое значение front назначено объекту reference, deque объект можно изменить.

Пример

// deque_front.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 11 );

   int& i = c1.front( );
   const int& ii = c1.front( );

   cout << "The first integer of c1 is " << i << endl;
   i++;
   cout << "The second integer of c1 is " << ii << endl;
}

The first integer of c1 is 10
The second integer of c1 is 11

`get_allocator`

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

Allocator get_allocator() const;

Возвращаемое значение

Распределитель, используемый параметром deque.

Замечания

Распределители для deque класса указывают, как класс управляет хранилищем. Распределители по умолчанию для классов контейнеров из стандартной библиотеки C++ достаточны для большинства задач программирования. Написание и использование собственного класса распределителя требует расширенных навыков работы с C++.

Пример

// deque_get_allocator.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   // The following lines declare objects that use the default allocator.
   deque <int> c1;
   deque <int, allocator<int> > c2 = deque <int, allocator<int> >( allocator<int>( ) );

   // c3 will use the same allocator class as c1
   deque <int> c3( c1.get_allocator( ) );

   deque <int>::allocator_type xlst = c1.get_allocator( );
   // You can now call functions on the allocator class used by c1
}

`insert`

Вставляет элемент или ряд элементов или диапазон элементов в deque указанное положение.

iterator insert(
    const_iterator Where,
    const Type& Val);

iterator insert(
    const_iterator Where,
    Type&& Val);

void insert(
    iterator Where,
    size_type Count,
    const Type& Val);

template <class InputIterator>
void insert(
    iterator Where,
    InputIterator First,
    InputIterator Last);

iterator insert(
    iterator Where,initializer_list<Type>
IList);

Параметры

Where
Позиция в целевом объекте deque , где вставляется первый элемент.

Val
Значение элемента, вставляемого в deque.

Count
Число вставляемых элементов в объект deque.

First
Позиция первого элемента в диапазоне элементов в аргументе deque для копирования.

Last
Позиция первого элемента за пределами диапазона элементов в аргументе deque для копирования.

IList
Элементы initializer_list для вставки.

Возвращаемое значение

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

Замечания

Любая операция вставки может быть ресурсоемкой.

`iterator`

Тип, предоставляющий итератор произвольного доступа, который может считывать или изменять любой элемент в deque.

typedef implementation-defined iterator;

Замечания

Тип iterator можно использовать для изменения значения элемента.

Пример

Пример см. в примере begin.

`max_size`

Возвращает максимальную длину deque.

size_type max_size() const;

Возвращаемое значение

Максимальная возможная длина deque.

Пример

// deque_max_size.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::size_type i;

   i = c1.max_size( );
   cout << "The maximum possible length of the deque is " << i << "." << endl;
}

`operator[]`

Возвращает ссылку на элемент deque в указанной позиции.

reference operator[](size_type pos);

const_reference operator[](size_type pos) const;

Параметры

pos
Положение элемента, deque на который необходимо ссылаться.

Возвращаемое значение

Ссылка на элемент, позиция которого указана в аргументе. Если указанное положение больше размера deque, результат не определен.

Замечания

Если возвращаемое значение operator[] назначено объекту const_reference, deque объект нельзя изменить. Если возвращаемое значение operator[] назначено объекту reference, deque объект можно изменить.

При компиляции с помощью _ITERATOR_DEBUG_LEVEL определенного значения 1 или 2 при попытке получить доступ к элементу за пределами границ этого dequeэлемента возникнет ошибка среды выполнения. Дополнительные сведения см. в разделе Checked Iterators .

Пример

// deque_op_ref.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 20 );
   cout << "The first integer of c1 is " << c1[0] << endl;
   int& i = c1[1];
   cout << "The second integer of c1 is " << i << endl;
}

The first integer of c1 is 10
The second integer of c1 is 20

`operator=`

Заменяет элементы этого deque с помощью элементов из другого deque.

deque& operator=(const deque& right);

deque& operator=(deque&& right);

Параметры

right
Объект deque , предоставляющий новое содержимое.

Замечания

Первый переопределение копирует элементы в это deque из rightисточника назначения. Второй переопределение перемещает элементы к этомуdeque.right

Элементы, содержащиеся в этом deque элементе перед выполнением оператора, удаляются.

Пример

// deque_operator_as.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>
using namespace std;

typedef deque<int> MyDeque;

template<typename MyDeque> struct S;

template<typename MyDeque> struct S<MyDeque&> {
  static void show( MyDeque& d ) {
    MyDeque::const_iterator iter;
    for (iter = d.cbegin(); iter != d.cend(); iter++)
       cout << *iter << " ";
    cout << endl;
  }
};

template<typename MyDeque> struct S<MyDeque&&> {
  static void show( MyDeque&& d ) {
    MyDeque::const_iterator iter;
    for (iter = d.cbegin(); iter != d.cend(); iter++)
       cout << *iter << " ";
cout << " via unnamed rvalue reference " << endl;
  }
};

int main( )
{
   MyDeque d1, d2;

   d1.push_back(10);
   d1.push_back(20);
   d1.push_back(30);
   d1.push_back(40);
   d1.push_back(50);

   cout << "d1 = " ;
   S<MyDeque&>::show( d1 );

   d2 = d1;
   cout << "d2 = ";
   S<MyDeque&>::show( d2 );

   cout << "     ";
   S<MyDeque&&>::show ( move< MyDeque& > (d1) );
}

`pointer`

Предоставляет указатель на элемент в объекте deque.

typedef typename Allocator::pointer pointer;

Замечания

Тип pointer можно использовать для изменения значения элемента. Чаще iterator используется для доступа к элементу deque .

`pop_back`

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

void pop_back();

Замечания

Последний элемент не должен быть пустым. pop_back никогда не создает исключений.

Пример

// deque_pop_back.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 1 );
   c1.push_back( 2 );
   cout << "The first element is: " << c1.front( ) << endl;
   cout << "The last element is: " << c1.back( ) << endl;

   c1.pop_back( );
   cout << "After deleting the element at the end of the deque, the "
      "last element is: " << c1.back( ) << endl;
}

The first element is: 1
The last element is: 2
After deleting the element at the end of the deque, the last element is: 1

`pop_front`

Удаляет элемент в начале элемента deque.

void pop_front();

Замечания

Первый элемент не должен быть пустым. pop_front никогда не создает исключений.

Пример

// deque_pop_front.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 1 );
   c1.push_back( 2 );
   cout << "The first element is: " << c1.front( ) << endl;
   cout << "The second element is: " << c1.back( ) << endl;

   c1.pop_front( );
   cout << "After deleting the element at the beginning of the "
      "deque, the first element is: " << c1.front( ) << endl;
}

The first element is: 1
The second element is: 2
After deleting the element at the beginning of the `deque`, the first element is: 2

`push_back`

Добавляет элемент в конец deque.

void push_back(const Type& val);

void push_back(Type&& val);

Параметры

val
Элемент, добавляемый в конец deque.

Замечания

При создании исключения deque не изменяется, а исключение создается снова.

`push_front`

Добавляет элемент в начало deque.

void push_front(const Type& val);
void push_front(Type&& val);

Параметры

val
Элемент, добавленный в начало dequeэлемента .

Замечания

При создании исключения deque не изменяется, а исключение создается снова.

Пример

// deque_push_front.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>
#include <string>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_front( 1 );
   if ( c1.size( ) != 0 )
      cout << "First element: " << c1.front( ) << endl;

   c1.push_front( 2 );
   if ( c1.size( ) != 0 )
      cout << "New first element: " << c1.front( ) << endl;

// move initialize a deque of strings
   deque <string> c2;
   string str("a");

   c2.push_front( move( str ) );
   cout << "Moved first element: " << c2.front( ) << endl;
}

First element: 1
New first element: 2
Moved first element: a

`rbegin`

Возвращает итератор первому элементу в обратном dequeпорядке.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Возвращаемое значение

Обратный итератор случайного доступа, обращаюющийся к первому элементу в обратном deque или адресу, который был последним элементом в непровернутом deque.

Замечания

rbegin используется с обратным deque так же, как begin используется с deque.

Если возвращаемое значение rbegin назначено объекту const_reverse_iterator, deque объект нельзя изменить. Если возвращаемое значение rbegin назначено объекту reverse_iterator, deque объект можно изменить.

rbegin можно использовать для перебора deque в обратном порядке.

Пример

// deque_rbegin.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::iterator c1_Iter;
   deque <int>::reverse_iterator c1_rIter;

   // If the following line had replaced the line above, an error
   // would have resulted in the line modifying an element
   // (commented below) because the iterator would have been const
   // deque <int>::const_reverse_iterator c1_rIter;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );

   c1_rIter = c1.rbegin( );
   cout << "Last element in the deque is " << *c1_rIter << "." << endl;

   cout << "The deque contains the elements: ";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << *c1_Iter << " ";
   cout << "in that order.";
   cout << endl;

   // rbegin can be used to iterate through a deque in reverse order
   cout << "The reversed deque is: ";
   for ( c1_rIter = c1.rbegin( ); c1_rIter != c1.rend( ); c1_rIter++ )
      cout << *c1_rIter << " ";
   cout << endl;

   c1_rIter = c1.rbegin( );
   *c1_rIter = 40;  // This would have caused an error if a
                    // const_reverse iterator had been declared as
                    // noted above
   cout << "Last element in deque is now " << *c1_rIter << "." << endl;
}

Last element in the deque is 30.
The deque contains the elements: 10 20 30 in that order.
The reversed deque is: 30 20 10
Last element in deque is now 40.

`reference`

Тип, предоставляющий ссылку на элемент, хранящийся в контейнере deque.

typedef typename Allocator::reference reference;

Пример

// deque_reference.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 20 );

   const int &i = c1.front( );
   int &j = c1.back( );
   cout << "The first element is " << i << endl;
   cout << "The second element is " << j << endl;
}

The first element is 10
The second element is 20

`rend`

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

const_reverse_iterator rend() const;

reverse_iterator rend();

Возвращаемое значение

Обратный итератор случайного доступа, который обращается к расположению, успешному последнему элементу в обратном deque направлении (расположение, которое предшествовало первому элементу в непровернутом deque).

Замечания

rend используется с обратным deque так же, как end используется с deque.

Если возвращаемое значение rend назначено объекту const_reverse_iterator, deque объект нельзя изменить. Если возвращаемое значение rend назначено объекту reverse_iterator, deque объект можно изменить.

rend можно использовать для проверки того, достиг ли обратный итератор конца его deque.

Возвращаемое rend значение не должно быть разоменовывано.

Пример

// deque_rend.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;

   deque <int> c1;
   deque <int>::iterator c1_Iter;
   deque <int>::reverse_iterator c1_rIter;
   // If the following line had replaced the line above, an error
   // would have resulted in the line modifying an element
   // (commented below) because the iterator would have been const
   // deque <int>::const_reverse_iterator c1_rIter;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );

   c1_rIter = c1.rend( );
   c1_rIter --; // Decrementing a reverse iterator moves it forward
                // in the deque (to point to the first element here)
   cout << "The first element in the deque is: " << *c1_rIter << endl;

   cout << "The deque is: ";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << *c1_Iter << " ";
   cout << endl;

   // rend can be used to test if an iteration is through all of
   // the elements of a reversed deque
   cout << "The reversed deque is: ";
   for ( c1_rIter = c1.rbegin( ); c1_rIter != c1.rend( ); c1_rIter++ )
      cout << *c1_rIter << " ";
   cout << endl;

   c1_rIter = c1.rend( );
   c1_rIter--; // Decrementing the reverse iterator moves it backward
               // in the reversed deque (to the last element here)
   *c1_rIter = 40; // This modification of the last element would
                   // have caused an error if a const_reverse
                   // iterator had been declared (as noted above)
   cout << "The modified reversed deque is: ";
   for ( c1_rIter = c1.rbegin( ); c1_rIter != c1.rend( ); c1_rIter++ )
      cout << *c1_rIter << " ";
   cout << endl;
}

The first element in the deque is: 10
The deque is: 10 20 30
The reversed deque is: 30 20 10
The modified reversed deque is: 30 20 40

`resize`

Указывает новый размер deque.

void resize(size_type _Newsize);

void resize(size_type _Newsize, Type val);

Параметры

_Newsize
Новый размер deque.

val
Значение новых элементов, добавляемых deque в размер, если новый размер больше, чем исходный размер. Если значение не задано, новым элементам назначается значение по умолчанию для класса.

Замечания

dequeЕсли значение меньше_Newsizesize, элементы добавляются в элементdeque, пока он не достигнет размера_Newsize.

dequeЕсли значение 's size больше_Newsize, то элементы, ближайшие к концу, deque удаляются до тех пор, пока deque не достигнет размера_Newsize.

Если размер данного deque объекта совпадает _Newsizeс размером, не выполняется никаких действий.

size отражает текущий dequeразмер объекта .

Пример

// deque_resize.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );

   c1.resize( 4,40 );
   cout << "The size of c1 is: " << c1.size( ) << endl;
   cout << "The value of the last element is " << c1.back( ) << endl;

   c1.resize( 5 );
   cout << "The size of c1 is now: " << c1.size( ) << endl;
   cout << "The value of the last element is now " << c1.back( ) << endl;

   c1.resize( 2 );
   cout << "The reduced size of c1 is: " << c1.size( ) << endl;
   cout << "The value of the last element is now " << c1.back( ) << endl;
}

The size of c1 is: 4
The value of the last element is 40
The size of c1 is now: 5
The value of the last element is now 0
The reduced size of c1 is: 2
The value of the last element is now 20

`reverse_iterator`

Тип, предоставляющий итератор случайного доступа, который может считывать или изменять элемент в обратном режиме deque.

typedef std::reverse_iterator<iterator> reverse_iterator;

Замечания

Тип reverse_iterator используется для итерации через deque.

Пример

См. пример для rbegin.

`shrink_to_fit`

Удаляет лишнюю емкость.

void shrink_to_fit();

Замечания

Нет переносимого способа определить, сокращает ли shrink_to_fit хранилище, используемое в объекте deque.

Пример

// deque_shrink_to_fit.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> v1;
   //deque <int>::iterator Iter;

   v1.push_back( 1 );
   v1.push_back( 2 );
   cout << "Current size of v1 = "
      << v1.size( ) << endl;
   v1.shrink_to_fit();
   cout << "Current size of v1 = "
      << v1.size( ) << endl;
}

Current size of v1 = 1
Current size of v1 = 1

`size`

Возвращает количество элементов в контейнере deque.

size_type size() const;

Возвращаемое значение

Текущая длина deque.

Пример

// deque_size.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::size_type i;

   c1.push_back( 1 );
   i = c1.size( );
   cout << "The deque length is " << i << "." << endl;

   c1.push_back( 2 );
   i = c1.size( );
   cout << "The deque length is now " << i << "." << endl;
}

The deque length is 1.
The deque length is now 2.

`size_type`

Тип, считающий количество элементов в deque.

typedef typename Allocator::size_type size_type;

Пример

Пример см. в примере size.

`swap`

Меняет местами элементы двух объектов deque.

void swap(deque<Type, Allocator>& right);

friend void swap(deque<Type, Allocator>& left, deque<Type, Allocator>& right) template <class Type, class Allocator>
void swap(deque<Type, Allocator>& left, deque<Type, Allocator>& right);

Параметры

right
Предоставление deque элементов, которые необходимо заменить, или deque элементы, которые необходимо обменять с элементами.deque left

left
Элементdeque, элементы которого должны быть обмениваются с элементами.deque right

Пример

// deque_swap.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1, c2, c3;
   deque <int>::iterator c1_Iter;

   c1.push_back( 1 );
   c1.push_back( 2 );
   c1.push_back( 3 );
   c2.push_back( 10 );
   c2.push_back( 20 );
   c3.push_back( 100 );

   cout << "The original deque c1 is:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;

   c1.swap( c2 );

   cout << "After swapping with c2, deque c1 is:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;

   swap( c1,c3 );

   cout << "After swapping with c3, deque c1 is:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;

   swap<>(c1, c2);
   cout << "After swapping with c2, deque c1 is:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;
}

The original deque c1 is: 1 2 3
After swapping with c2, deque c1 is: 10 20
After swapping with c3, deque c1 is: 100
After swapping with c2, deque c1 is: 1 2 3

`value_type`

Тип, который представляет тип данных, хранящийся в контейнере deque.

typedef typename Allocator::value_type value_type;

Замечания

value_type является синонимом для параметра-шаблона Type.

Пример

// deque_value_type.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>
int main( )
{
   using namespace std;
   deque<int>::value_type AnInt;
   AnInt = 44;
   cout << AnInt << endl;
}

См. также

Потокобезопасность в стандартной библиотеке C++
Справочник по стандартной библиотеке C++

Поделиться через

Класс deque

Синтаксис

Параметры

Замечания

Участники

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

Определения типов

Функции

Операторы

allocator_type

Замечания

Пример

assign

Параметры

Замечания

Пример

at

Параметры

Возвращаемое значение

Замечания

Пример

back

Возвращаемое значение

Замечания

Пример

begin

Возвращаемое значение

Замечания

Пример

cbegin

Возвращаемое значение

Замечания

cend

Возвращаемое значение

Замечания

clear

Пример

const_iterator

Замечания

Пример

const_pointer

Замечания

const_reference

Замечания

Пример

const_reverse_iterator

Замечания

Пример

crbegin

Возвращаемое значение

Замечания

Пример

crend

Возвращаемое значение

Замечания

Пример

deque

Параметры

Замечания

Пример

difference_type

Замечания

Пример

emplace

Параметры

Возвращаемое значение

Замечания

Пример

emplace_back

Параметры

Пример

emplace_front

Параметры

Пример

empty

Возвращаемое значение

Пример

end

Возвращаемое значение

Класс `deque`

`allocator_type`

`assign`

`at`

`back`

`begin`

`cbegin`

`cend`

`clear`

`const_iterator`

`const_pointer`

`const_reference`

`const_reverse_iterator`

`crbegin`

`crend`

`deque`

`difference_type`

`emplace`

`emplace_back`

`emplace_front`

`empty`

`end`

`erase`

`front`

`get_allocator`

`insert`

`iterator`

`max_size`

`operator[]`

`operator=`

`pointer`

`pop_back`

`pop_front`

`push_back`

`push_front`

`rbegin`

`reference`

`rend`

`resize`

`reverse_iterator`

`shrink_to_fit`