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

From cppreference.com
< cpp‎ | container‎ | deque

void shrink_to_fit(); |  | (since C++11)

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 and references are invalidated. end() iterator is also 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 <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:

    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

### See also

size | returns the number of elements (public member function)

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/container/deque/shrink_to_fit&oldid=135179"