std::get_temporary_buffer
| Definido en el archivo de encabezado <memory>
|
||
template< class T > std::pair<T*, std::ptrdiff_t> get_temporary_buffer( std::ptrdiff_t count ); |
(hasta C++11) | |
template< class T > std::pair<T*, std::ptrdiff_t> get_temporary_buffer( std::ptrdiff_t count ) noexcept; |
(desde C++11) (en desuso en C++17) (eliminado en C++20) |
|
Asigna almacenamiento contiguo no inicializado, que debería ser suficiente para almacenar hasta count objetos adyacentes de tipo T. La solicitud no es vinculante y la implementación puede asignar menos o más de lo necesario para almacenar count objetos adyacentes.
Parámetros
| count | - | El número deseado de objetos. |
Valor de retorno
Un std::pair que contiene un puntero al comienzo del almacenamiento asignado y la cantidad de objetos que caben en el almacenamiento que realmente se asignó.
Si no se pudo asignar memoria o el almacenamiento asignado no es suficiente para almacenar un único elemento de tipo T, el elemento first del resultado es un puntero nulo y el elemento second es cero.
Notas
Esta API se diseñó originalmente con la intención de proporcionar una implementación más eficiente que el operador new de propósito general, pero no se creó dicha implementación y la API quedó obsoleta y se eliminó.
Ejemplo
#include <algorithm>
#include <iostream>
#include <memory>
#include <string>
#include <iterator>
int main()
{
const std::string s[] = {"cadena", "1", "prueba", "..."};
const auto p = std::get_temporary_buffer<std::string>(4);
// requiere que p.first se pase a return_temporary_buffer
// (cuidado con los puntos de salida anticipada y las excepciones)
std::copy(s, s + p.second,
std::raw_storage_iterator<std::string*, std::string>(p.first));
// tiene el mismo efecto que: std::uninitialized_copy(s, s + p.second, p.first);
// requiere que cada cadena en p se destruya individualmente
// (cuidado con los puntos de salida anticipada y las excepciones)
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>();
}); // lo mismo que: std::destroy(p.first, p.first + p.second);
std::return_temporary_buffer(p.first);
}
Salida:
cadena
1
prueba
...
Véase también
(en desuso en C++17)(eliminado en C++20) |
Libera almacenamiento sin inicializar. (plantilla de función) |