Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::pmr::vector: risorse di memoria e allocatori degli elementi

Scegli una risorsa di memoria per un vettore PMR e scopri quando i suoi elementi ricevono la stessa risorsa e come si comporta invece un vettore ordinario.

Versione: ISO C++23; implementation support may vary

Sintassi

#include <vector>
#include <string>
#include <memory_resource>
#include <cstddef>

// Equivalent types (T is the element type):
// std::pmr::vector<T> = std::vector<T, std::pmr::polymorphic_allocator<T>>
// std::pmr::string = std::basic_string<char, std::char_traits<char>, std::pmr::polymorphic_allocator<char>>

// In a block scope:
std::byte buffer[4096];
std::pmr::monotonic_buffer_resource arena{buffer, sizeof buffer};
std::pmr::vector<std::pmr::string> data{&arena};
data.emplace_back("PMR");

std::pmr::vector<T> di <vector> è un alias di std::vector<T, std::pmr::polymorphic_allocator<T>>, non una classe contenitore distinta. std::pmr::string di <string> è std::basic_string per char con std::pmr::polymorphic_allocator<char>. Entrambi gli alias e std::byte sono stati introdotti in C++17 e fanno parte di C++23; il supporto può variare a seconda dell’implementazione.

Un allocatore polimorfico inoltra le richieste di allocazione a una std::pmr::memory_resource scelta in fase di esecuzione. Con data{&arena} scegli esplicitamente arena per la memoria destinata agli elementi del vettore. Un allocatore polimorfico costruito per default ottiene la risorsa corrente tramite std::pmr::get_default_resource(). Non va confusa con std::allocator<T>, il tipo di allocatore predefinito di un normale std::vector<T>.

Con emplace_back("PMR") su un std::pmr::vector<std::pmr::string>, la costruzione che tiene conto dell’allocatore passa la risorsa del vettore alla nuova stringa, che la usa se le serve memoria separata per i caratteri. Se DATA indica std::pmr::string, un normale std::vector<DATA> usa ancora std::allocator<DATA> per memorizzare gli elementi. In questa chiamata non passa alcuna risorsa al costruttore della stringa, che prende quindi la risorsa PMR predefinita. Viceversa, una std::string non inizia a usare PMR solo perché è un elemento di un vettore PMR.

std::byte di <cstddef> è un tipo enumerato con ambito proprio e tipo sottostante unsigned char. Un array di questo tipo fornisce qui memoria grezza a una std::pmr::monotonic_buffer_resource di <memory_resource>. Se lo spazio disponibile non basta per una richiesta, la risorsa chiede un altro blocco alla risorsa a monte. Se quest’ultima è std::pmr::null_memory_resource(), la richiesta lancia std::bad_alloc.

Il vettore non possiede la risorsa. Dichiara il buffer, la risorsa e il contenitore in quest’ordine, in modo che il contenitore venga distrutto per primo. Non chiamare release() finché esistono oggetti che dipendono dalla memoria allocata dalla risorsa. Una risorsa monotona non recupera spazio con le singole deallocazioni.

Esempi

#include <cstddef>
#include <iostream>
#include <memory_resource>
#include <string>
#include <type_traits>
#include <vector>

int main() {
    using DATA = std::pmr::string;
    static_assert(std::is_same_v<std::vector<DATA>::allocator_type,
                                 std::allocator<DATA>>);

    std::byte buffer[4096];
    std::pmr::monotonic_buffer_resource arena{buffer, sizeof buffer};
    std::pmr::vector<DATA> pmr_data{&arena};
    std::vector<DATA> ordinary_data;

    pmr_data.emplace_back("PMR");
    ordinary_data.emplace_back("PMR");

    std::cout << std::boolalpha
              << "PMR vector uses arena: "
              << (pmr_data.get_allocator().resource() == &arena) << '\n'
              << "PMR vector element uses arena: "
              << (pmr_data.front().get_allocator().resource() == &arena) << '\n'
              << "Ordinary vector element uses default resource: "
              << (ordinary_data.front().get_allocator().resource() ==
                  std::pmr::get_default_resource()) << '\n';
}

Risultato

PMR vector uses arena: true
PMR vector element uses arena: true
Ordinary vector element uses default resource: true

L’asserzione statica controlla il tipo di allocatore del vettore ordinario. I tre risultati `true` confermano l’identità delle risorse, non l’allocazione di memoria per i caratteri: una stringa breve può stare all’interno del proprio oggetto.

Lezioni correlate

  • C++ · Lezione 18 · Avanzato · Versione: 3

Fonti