home | help 
std::deque::shrink_to_fit(3)   C++ Standard Libary  std::deque::shrink_to_fit(3)

NAME
     std::deque::shrink_to_fit - std::deque::shrink_to_fit

Synopsis
	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 references are invali-
     dated.

Parameters
	(none)

Type requirements
	-
	T must meet the requirements of MoveInsertable into *this. (since C++11)

Return value
	(none)

Complexity
	At most linear in the size of the container.

Exceptions
									       (since
     C++11)
	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
     // Run this code

      #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:
      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	retroac-
     tively to
	previously published C++ standards.

	   DR	 Applied to		 Behavior as published		    Cor-
     rect behavior
	LWG 850  C++98	    std::deque lacked explicit shrink-to-fit	    pro-
     vided
			    operations
	LWG  2033  C++11      1. T was not required to be MoveInsertable      1.
     required
			    2. the complexity requirement was  missing	      2.
     added

See also
	size returns the number of elements
	     (public member function)

http://cppreference.com 	   2024.06.10	    std::deque::shrink_to_fit(3)
home | help