home | help 
std::allocator::deallocate(3)  C++ Standard Libary std::allocator::deallocate(3)

NAME
     std::allocator::deallocate - std::allocator::deallocate

Synopsis
	void deallocate( T* p, std::size_t n );  (constexpr since C++20)

	Deallocates  the  storage  referenced  by the pointer p, which must be a
     pointer
	obtained by an earlier call to allocate()
	or allocate_at_least()
	(since C++23).

	The argument n must be equal to the first argument of the call to  allo-
     cate() that
	originally produced p
	,  or  in  the	range  [m,  count] if p is obtained from a call to allo-
     cate_at_least(m)
	which returned {p, count}
	(since C++23); otherwise, the behavior is undefined.

	Calls ::operator delete(void*)
	or ::operator delete(void*, std::align_val_t)
	(since C++17), but it is unspecified when and how it is called.

	In evaluation of a constant expression, this  function	must  deallocate
     (since C++20)
	storage allocated within the evaluation of the same expression.

Parameters
	    pointer obtained from allocate()
	p - or allocate_at_least()
	    (since C++23)
	    number of objects earlier passed to allocate()
	n - , or a number between requested and actually allocated number of ob-
     jects via
	    allocate_at_least() (may be equal to either bound)
	    (since C++23)

Return value
	(none)

Example
     // Run this code

      #include <algorithm>
      #include <cstddef>
      #include <iostream>
      #include <memory>
      #include <string>

      class S
      {
	  inline static int n{1};
	  int m{};
	  void pre() const { std::cout << "#" << m << std::string(m, ' '); }
      public:
	  S(int x) : m{n++} { pre(); std::cout << "S::S(" << x << ");\n"; }
	  ~S() { pre(); std::cout << "S::~S();\n"; }
	  void id() const { pre(); std::cout << "S::id();\n"; }
      };

      int main()
      {
	  constexpr std::size_t n{4};
	  std::allocator<S> allocator;
	  try
	  {
	      S* s = allocator.allocate(n); // may throw
	      for (std::size_t i{}; i != n; ++i)
	      {
	      //  allocator.construct(&s[i], i + 42); // removed in C++20
		  std::construct_at(&s[i], i + 42);   // since C++20
	      }
	      std::for_each_n(s, n, [](const auto& e) { e.id(); });
	      std::destroy_n(s, n);
	      allocator.deallocate(s, n);
	  }
	  catch  (std::bad_array_new_length  const& ex) { std::cout << ex.what()
     << '\n'; }
	  catch (std::bad_alloc const& ex) { std::cout << ex.what() << '\n'; }
      }

Output:
      #1 S::S(42);
      #2  S::S(43);
      #3   S::S(44);
      #4    S::S(45);
      #1 S::id();
      #2  S::id();
      #3   S::id();
      #4    S::id();
      #1 S::~S();
      #2  S::~S();
      #3   S::~S();
      #4    S::~S();

See also
	allocate	  allocates uninitialized storage
			  (public member function)
	allocate_at_least allocates uninitialized storage at least as  large  as
     requested
	(C++23) 	  size
			  (public member function)
	deallocate	  deallocates storage using the allocator
	[static]	    (public   static  member  function	of  std::alloca-
     tor_traits<Alloc>)

http://cppreference.com 	   2024.06.10	   std::allocator::deallocate(3)
home | help