std::vector<T,Allocator>::shrink_to_fit

void shrink_to_fit();		(since C++11) (until C++20)
constexpr void shrink_to_fit();		(since C++20)

Requests the removal of unused capacity.

It is a non-binding request to reduce capacity() to size(). It depends on the implementation whether the request is fulfilled.

If new size() is greater than capacity() the function causes reallocation, in which case all iterators (including the end() iterator) and all references to the elements are invalidated. If no reallocation takes place, no iterators or references are invalidated.

Parameters

(none)

Type requirements
- `T` must meet the requirements of MoveInsertable.

Return value

(none)

Complexity

At most linear in the size of the container.

Notes

If an exception is thrown other than by T's move constructor, there are no effects.

Example

Run this code

#include <iostream>
#include <vector>
 
int main()
{
    std::vector<int> v;
    std::cout << "Default-constructed capacity is " << v.capacity() << '\n';
    v.resize(100);
    std::cout << "Capacity of a 100-element vector is " << v.capacity() << '\n';
    v.resize(50);
    std::cout << "Capacity after resize(50) is " << v.capacity() << '\n';
    v.shrink_to_fit();
    std::cout << "Capacity after shrink_to_fit() is " << v.capacity() << '\n';
    v.clear();
    std::cout << "Capacity after clear() is " << v.capacity() << '\n';
    v.shrink_to_fit();
    std::cout << "Capacity after shrink_to_fit() is " << v.capacity() << '\n';
    for (int i = 1000; i < 1300; ++i)
        v.push_back(i);
    std::cout << "Capacity after adding 300 elements is " << v.capacity() << '\n';
    v.shrink_to_fit();
    std::cout << "Capacity after shrink_to_fit() is " << v.capacity() << '\n';
}

Possible output:

Default-constructed capacity is 0
Capacity of a 100-element vector is 100
Capacity after resize(50) is 100
Capacity after shrink_to_fit() is 50
Capacity after clear() is 50
Capacity after shrink_to_fit() is 0
Capacity after adding 300 elements is 512
Capacity after shrink_to_fit() is 300

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)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Concurrency support library (C++11)
Technical specifications
Symbols index
External libraries

Sequence
array (C++11)
vector
vector<bool>
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)
Iterator invalidation
Member function table
Non-member function table

Member types
Member functions
vector::vector
vector::~vector
vector::operator=
vector::assign
vector::assign_range (C++23)
vector::get_allocator
Element access
vector::at
vector::operator[]
vector::front
vector::back
vector::data
Iterators
vector::beginvector::cbegin (C++11)
vector::endvector::cend (C++11)
vector::rbeginvector::crbegin (C++11)
vector::rendvector::crend (C++11)
Capacity
vector::empty
vector::size
vector::max_size
vector::reserve
vector::capacity
vector::shrink_to_fit (DR*)
Modifiers
vector::clear
vector::insert
vector::emplace (C++11)
vector::insert_range (C++23)
vector::erase
vector::push_back
vector::emplace_back (C++11)
vector::append_range (C++23)
vector::pop_back
vector::resize
vector::swap
Non-member functions
std::swap
eraseerase_if (C++20)(C++20)
operator==operator!=operator<operator>operator<=operator>=operator<=> (until C++20)(until C++20)(until C++20)(until C++20)(until C++20)(C++20)
Deduction guides(C++17)