deduction guides for std::deque

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros(C++20)

Language support library

Concepts library(C++20)

Diagnostics library

Memory management library

Metaprogramming library(C++11)

General utilities library

Containers library

Iterators library

Ranges library(C++20)

Algorithms library

Strings library

Text processing library

Numerics library

Date and time library

Input/output library

Filesystem library(C++17)

Concurrency support library(C++11)

Execution control library(C++26)

Technical specifications

Symbols index

External libraries

 

Containers library

node-handle (C++17)

Sequence

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

hive (C++26)

deque

forward_list (C++11)

list

Associative

set

multiset

map

multimap

Unordered associative

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adaptors

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Views

span (C++20)

mdspan (C++23)

Tables

Iterator invalidation

Member function table

Non-member function table

 

std::deque

Member types
Member functions
deque::deque deque::~deque deque::operator= deque::assign deque::assign_range (C++23)   deque::get_allocator Element access deque::at deque::operator[] deque::front deque::back Iterators deque::begindeque::cbegin (C++11) deque::enddeque::cend (C++11) deque::rbegindeque::crbegin (C++11) deque::renddeque::crend (C++11)	Capacity deque::empty deque::size deque::max_size deque::shrink_to_fit (DR*) Modifiers deque::clear deque::insert deque::insert_range (C++23) deque::emplace deque::erase deque::push_front deque::emplace_front (C++11) deque::prepend_range (C++23) deque::pop_front deque::push_back deque::emplace_back (C++11) deque::append_range (C++23) deque::pop_back deque::resize deque::swap
Non-member functions
operator==operator<=> (C++20) swap(std::deque) erase(std::deque)erase_if(std::deque) (C++20)(C++20)	operator!=operator<operator>operator<=operator>= (until C++20)(until C++20)(until C++20)(until C++20)(until C++20)
Deduction guides(C++17)

 

Defined in header <deque>
template<class InputIt,           class Alloc =std::allocator<               typenamestd::iterator_traits<InputIt>::value_type>> deque( InputIt, InputIt, Alloc = Alloc())     -> deque<typenamestd::iterator_traits<InputIt>::value_type, Alloc>;	(1)	(since C++17)
template<ranges::input_range R,           class Alloc =std::allocator<ranges::range_value_t<R>>> deque(std::from_range_t, R&&, Alloc = Alloc())     -> deque<ranges::range_value_t<R>, Alloc>;	(2)	(since C++23)

1) This deduction guide is provided for deque to allow deduction from an iterator range. This overload participates in overload resolution only if InputIt satisfies LegacyInputIterator and Alloc satisfies Allocator.

2) This deduction guide is provided for deque to allow deduction from a std::from_range_t tag and an input_range.

Note: the extent to which the library determines that a type does not satisfy LegacyInputIterator is unspecified, except that as a minimum integral types do not qualify as input iterators. Likewise, the extent to which it determines that a type does not satisfy Allocator is unspecified, except that as a minimum the member type Alloc::value_type must exist and the expression std::declval<Alloc&>().allocate(std::size_t{}) must be well-formed when treated as an unevaluated operand.

Notes

Feature-test macro	Value	Std	Feature
__cpp_lib_containers_ranges	202202L	(C++23)	Ranges-aware construction and insertion; overload (2)

Example

Run this code

#include <deque>#include <vector>   int main(){std::vector<int> v ={1, 2, 3, 4};   // uses explicit deduction guide to deduce std::deque<int>std::deque x(v.begin(), v.end());   // deduces std::deque<std::vector<int>::iterator>// first phase of overload resolution for list-initialization selects the candidate// synthesized from the initializer-list constructor; second phase is not performed// and deduction guide has no effectstd::deque y{v.begin(), v.end()};}