24
Containers library
[containers]
24.3
Sequence containers
[sequences]
24.3.9
Class template
deque
[deque]
24.3.9.1
Overview
[deque.overview]
1
#
A
deque
is a sequence container that supports
random access iterators
.
In addition, it supports constant time insert and erase operations at the beginning or the end; insert and erase in the middle take linear time
.
That is, a deque is especially optimized for pushing and popping elements at the beginning and end
.
Storage management is handled automatically
.
2
#
A
deque
meets all of the requirements of a container (
[container.
reqmts]
), of a reversible container (
[container.
rev.
reqmts]
), of an allocator-aware container (
[container.
alloc.
reqmts]
), and of a sequence container, including the optional sequence container requirements (
[sequence.
reqmts]
)
.
Descriptions are provided here only for operations on
deque
that are not described in one of these tables or for operations where there is additional semantic information
.
namespace
std
{
template
<
class
T,
class
Allocator
=
allocator
<
T
>
>
class
deque
{
public
:
// types
using
value_type
=
T;
using
allocator_type
=
Allocator;
using
pointer
=
typename
allocator_traits
<
Allocator
>
::
pointer;
using
const_pointer
=
typename
allocator_traits
<
Allocator
>
::
const_pointer;
using
reference
=
value_type
&
;
using
const_reference
=
const
value_type
&
;
using
size_type
=
implementation-defined
;
// see
[container.
requirements]
using
difference_type
=
implementation-defined
;
// see
[container.
requirements]
using
iterator
=
implementation-defined
;
// see
[container.
requirements]
using
const_iterator
=
implementation-defined
;
// see
[container.
requirements]
using
reverse_iterator
=
std
::
reverse_iterator
<
iterator
>
;
using
const_reverse_iterator
=
std
::
reverse_iterator
<
const_iterator
>
;
//
[deque.
cons]
, construct/copy/destroy
deque
(
)
:
deque
(
Allocator
(
)
)
{
}
explicit
deque
(
const
Allocator
&
)
;
explicit
deque
(
size_type n,
const
Allocator
&
=
Allocator
(
)
)
; deque
(
size_type n,
const
T
&
value,
const
Allocator
&
=
Allocator
(
)
)
;
template
<
class
InputIterator
>
deque
(
InputIterator first, InputIterator last,
const
Allocator
&
=
Allocator
(
)
)
;
template
<
container-compatible-range
<
T
>
R
>
deque
(
from_range_t, R
&
&
rg,
const
Allocator
&
=
Allocator
(
)
)
; deque
(
const
deque
&
x
)
; deque
(
deque
&
&
)
; deque
(
const
deque
&
,
const
type_identity_t
<
Allocator
>
&
)
; deque
(
deque
&
&
,
const
type_identity_t
<
Allocator
>
&
)
; deque
(
initializer_list
<
T
>
,
const
Allocator
&
=
Allocator
(
)
)
;
~
deque
(
)
; deque
&
operator
=
(
const
deque
&
x
)
; deque
&
operator
=
(
deque
&
&
x
)
noexcept
(
allocator_traits
<
Allocator
>
::
is_always_equal
::
value
)
; deque
&
operator
=
(
initializer_list
<
T
>
)
;
template
<
class
InputIterator
>
void
assign
(
InputIterator first, InputIterator last
)
;
template
<
container-compatible-range
<
T
>
R
>
void
assign_range
(
R
&
&
rg
)
;
void
assign
(
size_type n,
const
T
&
t
)
;
void
assign
(
initializer_list
<
T
>
)
; allocator_type get_allocator
(
)
const
noexcept
;
// iterators
iterator begin
(
)
noexcept
; const_iterator begin
(
)
const
noexcept
; iterator end
(
)
noexcept
; const_iterator end
(
)
const
noexcept
; reverse_iterator rbegin
(
)
noexcept
; const_reverse_iterator rbegin
(
)
const
noexcept
; reverse_iterator rend
(
)
noexcept
; const_reverse_iterator rend
(
)
const
noexcept
; const_iterator cbegin
(
)
const
noexcept
; const_iterator cend
(
)
const
noexcept
; const_reverse_iterator crbegin
(
)
const
noexcept
; const_reverse_iterator crend
(
)
const
noexcept
;
//
[deque.
capacity]
, capacity
bool
empty
(
)
const
noexcept
; size_type size
(
)
const
noexcept
; size_type max_size
(
)
const
noexcept
;
void
resize
(
size_type sz
)
;
void
resize
(
size_type sz,
const
T
&
c
)
;
void
shrink_to_fit
(
)
;
// element access
reference
operator
[
]
(
size_type n
)
; const_reference
operator
[
]
(
size_type n
)
const
; reference at
(
size_type n
)
; const_reference at
(
size_type n
)
const
; reference front
(
)
; const_reference front
(
)
const
; reference back
(
)
; const_reference back
(
)
const
;
//
[deque.
modifiers]
, modifiers
template
<
class
.
.
.
Args
>
reference emplace_front
(
Args
&
&
.
.
.
args
)
;
template
<
class
.
.
.
Args
>
reference emplace_back
(
Args
&
&
.
.
.
args
)
;
template
<
class
.
.
.
Args
>
iterator emplace
(
const_iterator position, Args
&
&
.
.
.
args
)
;
void
push_front
(
const
T
&
x
)
;
void
push_front
(
T
&
&
x
)
;
template
<
container-compatible-range
<
T
>
R
>
void
prepend_range
(
R
&
&
rg
)
;
void
push_back
(
const
T
&
x
)
;
void
push_back
(
T
&
&
x
)
;
template
<
container-compatible-range
<
T
>
R
>
void
append_range
(
R
&
&
rg
)
; iterator insert
(
const_iterator position,
const
T
&
x
)
; iterator insert
(
const_iterator position, T
&
&
x
)
; iterator insert
(
const_iterator position, size_type n,
const
T
&
x
)
;
template
<
class
InputIterator
>
iterator insert
(
const_iterator position, InputIterator first, InputIterator last
)
;
template
<
container-compatible-range
<
T
>
R
>
iterator insert_range
(
const_iterator position, R
&
&
rg
)
; iterator insert
(
const_iterator position, initializer_list
<
T
>
)
;
void
pop_front
(
)
;
void
pop_back
(
)
; iterator erase
(
const_iterator position
)
; iterator erase
(
const_iterator first, const_iterator last
)
;
void
swap
(
deque
&
)
noexcept
(
allocator_traits
<
Allocator
>
::
is_always_equal
::
value
)
;
void
clear
(
)
noexcept
;
}
;
template
<
class
InputIterator,
class
Allocator
=
allocator
<
iter-value-type
<
InputIterator
>
>
>
deque
(
InputIterator, InputIterator, Allocator
=
Allocator
(
)
)
-
>
deque
<
iter-value-type
<
InputIterator
>
, Allocator
>
;
template
<
ranges
::
input_
range
R,
class
Allocator
=
allocator
<
ranges
::
range_value_t
<
R
>
>
>
deque
(
from_range_t, R
&
&
, Allocator
=
Allocator
(
)
)
-
>
deque
<
ranges
::
range_value_t
<
R
>
, Allocator
>
;
}