Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help 
std::get_temporary_buffer(3)  C++ Standard Libary 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	suffi-
       cient 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	 allo-
       cated.

	  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)

http://cppreference.com		  2022.07.31	  std::get_temporary_buffer(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::get_temporary_buffer&sektion=3&manpath=FreeBSD+Ports+15.0>

home | help