std:: get_temporary_buffer

Si count es negativo o cero, no hace nada.

De lo contrario, solicita asignar almacenamiento contiguo no inicializado para count objetos adyacentes de tipo T . La solicitud no es vinculante, y la implementación puede en su lugar asignar el almacenamiento para cualquier otro número de (incluyendo cero) objetos adyacentes de tipo T .

Parámetros

Valor de retorno

Un std::pair , el miembro first es un puntero al inicio del almacenamiento asignado y el miembro second es el número de objetos que caben en el almacenamiento que fue realmente asignado.

Si count <= 0 o el almacenamiento asignado no es suficiente para almacenar un solo elemento de tipo T , el miembro first del resultado es un puntero nulo y el miembro second es cero.

Notas

Esta API fue diseñada originalmente con la intención de proporcionar una implementación más eficiente que el operator new de propósito general, pero no se creó dicha implementación y la API fue descontinuada y eliminada.

Ejemplo

#include <algorithm>
#include <iostream>
#include <iterator>
#include <memory>
#include <string>
int main()
{
    const std::string s[] = {"string", "1", "test", "..."};
    const auto p = std::get_temporary_buffer<std::string>(4);
    // requiere que p.first se pase a return_temporary_buffer
    // (cuidado con puntos de salida temprana y excepciones), o mejor usar:
    std::unique_ptr<std::string, void(*)(std::string*)> on_exit(p.first,
    [](std::string* p)
    {
        std::cout << "returning temporary buffer...\n";
        std::return_temporary_buffer(p);
    });
    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 string en p sea destruido individualmente
    // (cuidado con puntos de salida temprana y 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>();
    }); // igual que: std::destroy(p.first, p.first + p.second);
    // reclamar memoria manualmente si no se usa la técnica similar a unique_ptr:
    // std::return_temporary_buffer(p.first);
}

string
1
test
...
returning temporary buffer...

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares publicados anteriormente de C++.

Véase también