std::get_temporary_buffer(3)

NAME
std::get_temporary_buffer - std::get_temporary_buffer

Synopsis
   Defined in header <memory>
   template< class T >
   std::pair<T*, std::ptrdiff_t> (until C++11)
   get_temporary_buffer( std::ptrdiff_t count );
   template< class T >
                        (since C++11)
   std::pair<T*, std::ptrdiff_t> (deprecated in C++17)
                        (removed in C++20)
   get_temporary_buffer( std::ptrdiff_t count ) noexcept;
   Allocates uninitialized contiguous storage, which should be sufficient to store up
   to count adjacent objects of type T. The request is non-binding and the
   implementation may allocate less or more than necessary to store count adjacent
   objects.

Parameters
   count - the desired number of objects

Return value
   A std::pair holding a pointer to the beginning of the allocated storage and the
   number of objects that fit in the storage that was actually allocated.
   If no memory could be allocated, or allocated storage is not enough to store a
   single element of type T, the first element of the result is a null pointer and the
   second element is zero.

Notes
   This API was originally designed with the intent of providing a more efficient
   implementation than the general-purpose operator new, but no such implementation was
   created and the API was deprecated and removed.

Example
// Run this code
 #include <algorithm>
 #include <iostream>
 #include <memory>
 #include <string>
 #include <iterator>
 int main()
 {
     const std::string s[] = {"string", "1", "test", "..."};
     const auto p = std::get_temporary_buffer<std::string>(4);
     // requires that p.first is passed to return_temporary_buffer
     // (beware of early exit points and exceptions)
     std::copy(s, s + p.second,
               std::raw_storage_iterator<std::string*, std::string>(p.first));
     // has same effect as: std::uninitialized_copy(s, s + p.second, p.first);
     // requires that each string in p is individually destroyed
     // (beware of early exit points and exceptions)
     std::copy(p.first, p.first + p.second,
               std::ostream_iterator<std::string>{std::cout, "\n"});
     std::for_each(p.first, p.first + p.second, [](std::string& e) {
         e.~basic_string<char>();
     }); // same as: std::destroy(p.first, p.first + p.second);
     std::return_temporary_buffer(p.first);
 }

Output:
 string
 1
 test
 ...

See also
   return_temporary_buffer frees uninitialized storage
   (deprecated in C++17) (function template)
   (removed in C++20)