Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Allocator e risorse di memoria

Un allocator determina come un contenitore ottiene e rilascia memoria. Le risorse std::pmr consentono di scegliere il comportamento di allocazione a runtime senza cambiare il tipo del contenitore, ma richiedono attenzione all’ordine di vita degli oggetti.

Versione: C++23; repository compiler flag, production runtime not attested

Sintassi

using Vector = std::vector<T, Allocator>;
using AllocatorTraits = std::allocator_traits<Allocator>;
using PolymorphicAllocator = std::pmr::polymorphic_allocator<T>;
std::pmr::vector<T> values(std::pmr::polymorphic_allocator<T>{&resource});

Un allocator descrive un modello di allocazione della memoria. In std::vector<T, Allocator>, il suo tipo fa parte del tipo del contenitore; il valore predefinito è std::allocator<T>. std::allocator_traits<Allocator> fornisce un’interfaccia uniforme per allocazione, deallocazione e costruzione e distruzione degli elementi. Ottenere memoria non equivale a invocare i costruttori degli elementi; di norma è il contenitore a gestire questa distinzione.

std::pmr::memory_resource offre un’interfaccia polimorfica che alloca blocchi in base al numero di byte e all’allineamento. std::pmr::polymorphic_allocator<T> traduce le richieste relative a T in richieste per questa interfaccia. std::pmr::vector<T> usa questo allocator: due vettori di questo tipo possono avere lo stesso tipo, ma risorse diverse selezionate a runtime. L’allocator non acquisisce la proprietà della risorsa.

std::pmr::monotonic_buffer_resource alloca porzioni successive di un buffer; una singola deallocazione non recupera memoria. Quando lo spazio termina, usa la risorsa a monte. Nell’esempio, std::pmr::null_memory_resource() fa sì che la richiesta generi std::bad_alloc invece di ottenere memoria aggiuntiva. reserve(3) evita riallocazioni durante le tre successive operazioni push_back, ma la capacità esatta scelta dipende dall’implementazione.

Il buffer deve durare più a lungo della risorsa che lo usa, e la risorsa più a lungo del contenitore. L’ordine delle dichiarazioni nell’esempio garantisce l’ordine inverso di distruzione: values, resource, buffer. Non chiamare release() finché il contenitore ha ancora bisogno della memoria allocata; il rilascio della risorsa non invoca i distruttori degli elementi memorizzati.

Questa voce riguarda C++23. L’URL fornito porta a una bozza in evoluzione, non a un’edizione definitiva di C++23. Il codice mostrato è stato eseguito senza modifiche in un ambiente isolato e il suo output standard corrispondeva esattamente a quello indicato. La verifica nell’ambiente di produzione è distinta: né questo test né l’opzione del compilatore nel repository dimostrano che l’esempio funzioni in quell’ambiente.

Esempi

#include <array>
#include <cstddef>
#include <iostream>
#include <memory_resource>
#include <vector>

int main() {
    alignas(int) std::array<std::byte, 1024> buffer{};
    std::pmr::monotonic_buffer_resource resource{
        buffer.data(), buffer.size(), std::pmr::null_memory_resource()};
    std::pmr::vector<int> values{&resource};
    values.reserve(3);
    values.push_back(10);
    values.push_back(20);
    values.push_back(30);

    std::cout << values.size() << '\n';
    std::cout << values[0] + values[1] + values[2] << '\n';
}

Risultato

3
60

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti