std::deque<T,Allocator>::resize

From cppreference.com

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

[edit]

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

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)

[edit]

void resize( size_type count);	(1)	(constexpr since C++26)
void resize( size_type count,const value_type& value);	(2)	(constexpr since C++26)

Resizes the container to containcount elements:

Ifcount is equal to the current size, does nothing.
If the current size is greater thancount, the container is reduced to its firstcount elements.
If the current size is less thancount, then:

1) Additionalcopies ofT()(until C++11)default-inserted elements(since C++11) are appended.

2) Additional copies ofvalue are appended.

[edit]Parameters

count - new size of the container

value - the value to initialize the new elements with

Type requirements

If the following condition is satisfied, the behavior is undefined:

1)T is notDefaultInsertable orMoveInsertable intodeque.

2)T is notCopyInsertable intodeque.

(since C++11)

[edit]Complexity

Linear in the difference between the current size andcount.

Notes

If value-initialization in overload(1) is undesirable, for example, if the elements are of non-class type and zeroing out is not needed, it can be avoided by providing acustomAllocator::construct.

[edit]Example

Run this code

#include <deque>#include <iostream> void print(auto rem,conststd::deque<int>& c){for(std::cout<< rem;constint el: c)std::cout<< el<<' ';std::cout<<'\n';} int main(){std::deque<int> c={1,2,3};    print("The deque holds: ", c);     c.resize(5);    print("After resize up to 5: ", c);     c.resize(2);    print("After resize down to 2: ", c);     c.resize(6,4);    print("After resize up to 6 (initializer = 4): ", c);}

Output:

The deque holds: 1 2 3After resize up to 5: 1 2 3 0 0After resize down to 2: 1 2After resize up to 6 (initializer = 4): 1 2 4 4 4 4

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR	Applied to	Behavior as published	Correct behavior
LWG 679	C++98	`resize()` passedvalue by value	passes by const reference
LWG 1418	C++98	the behavior ofresize(size()) was not specified	specified
LWG 2033	C++11	1. elements were removed by usingerase()^[1] 2.`T` was not required to beMoveInsertable	1. usespop_back() 2. required
LWG 2066	C++11	overload(1) did not have the exception safety guarantee of overload(2)	added
LWG 2160	C++11	elements were removed by usingpop_back()^[2] due to the resolution of LWG 2033	does not specify the method of removing elements

↑erase() can remove elements in the middle of adeque, so the value type is required to beMoveAssignable so that the elements following the removed section can be moved forward to fill the gap. However,resize() can only remove elements at the end of thedeque, making theMoveAssignable unnecessary.
↑Removing elements by usingpop_back() implies that the elements are required to be removed from back to front.

[edit]See also

max_size	returns the maximum possible number of elements (public member function)[edit]
size	returns the number of elements (public member function)[edit]
empty	checks whether the container is empty (public member function)[edit]