# std::deque<T,Allocator>::shrink_to_fit

> C++ Atlas: `cppatlas.com/w/cpp/container/deque/shrink_to_fit` | Source: https://en.cppreference.com/w/cpp/container/deque/shrink_to_fit | Domain: Containers | Standards: C++11

Requests the removal of unused capacity.

## Official Specification Summary (cppreference)

```cpp
void shrink_to_fit();
```

Requests the removal of unused capacity.

It is a non-binding request to reduce the memory usage without changing the size of the sequence. It depends on the implementation whether the request is fulfilled.

All iterators (including the `end()` iterator) and all references to the elements are invalidated.

If `T` is not *MoveInsertable* into `std::deque<T, Allocator>`, the behavior is undefined. (since C++11)

### Complexity

At most linear in the size of the container.

(since C++11):

### Exceptions

If an exception is thrown other than by the move constructor of a non-*CopyInsertable* `T`, there are no effects.

### Notes

In libstdc++, `shrink_to_fit()` is not available in C++98 mode.

### Example

```cpp
#include <cstddef>
#include <deque>
#include <iostream>
#include <new>

// Minimal C++11 allocator with debug output.
template<class Tp>
struct NAlloc
{
    typedef Tp value_type;

    NAlloc() = default;

    template<class T> NAlloc(const NAlloc<T>&) {}

    Tp* allocate(std::size_t n)
    {
        n *= sizeof(Tp);
        std::cout << "allocating " << n << " bytes\n";
        return static_cast<Tp*>(::operator new(n));
    }

    void deallocate(Tp* p, std::size_t n)
    {
        std::cout << "deallocating " << n*sizeof*p << " bytes\n";
        ::operator delete(p);
    }
};
template<class T, class U>
bool operator==(const NAlloc<T>&, const NAlloc<U>&) { return true; }
template<class T, class U>
bool operator!=(const NAlloc<T>&, const NAlloc<U>&) { return false; }

int main()
{
    // std::queue has no capacity() function (like std::vector).
    // Because of this, we use a custom allocator to show the
    // working of shrink_to_fit.

    std::cout << "Default-construct deque:\n";
    std::deque<int, NAlloc<int>> deq;

    std::cout << "\nAdd 300 elements:\n";
    for (int i = 1000; i < 1300; ++i)
        deq.push_back(i);

    std::cout << "\nPop 100 elements:\n";
    for (int i = 0; i < 100; ++i)
        deq.pop_front();

    std::cout << "\nRun shrink_to_fit:\n";
    deq.shrink_to_fit();

    std::cout << "\nDestroy deque as it goes out of scope:\n";
}
```

Possible output:

```text
Default-construct deque:
allocating 64 bytes
allocating 512 bytes

Add 300 elements:
allocating 512 bytes
allocating 512 bytes

Pop 100 elements:

Run shrink_to_fit:
allocating 64 bytes
allocating 512 bytes
allocating 512 bytes
deallocating 512 bytes
deallocating 512 bytes
deallocating 512 bytes
deallocating 64 bytes

Destroy deque as it goes out of scope:
deallocating 512 bytes
deallocating 512 bytes
deallocating 64 bytes
```

### 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 850 | C++98 | `std::deque` lacked explicit shrink-to-fit operations | provided |
| LWG 2033 | C++98 C++11 | 1. the complexity requirement was missing (C++98) 2. `T` was not required to be *MoveInsertable* (C++11) | 1. added 2. required |
| LWG 2223 | C++98 C++11 | 1. references, pointers, and iterators were not invalidated (C++98) 2. there was no exception safety guarantee (C++11) | 1. they may be invalidated 2. added |

### See also

- [`size`](https://en.cppreference.com/w/cpp/container/deque/size): returns the number of elements (public member function)

---
Attribution: content from https://en.cppreference.com/w/cpp/container/deque/shrink_to_fit (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.