Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

Allocateurs et ressources mémoire

Un allocateur détermine comment un conteneur obtient et libère de la mémoire. Les ressources std::pmr permettent de choisir le comportement d’allocation à l’exécution sans changer le type du conteneur, mais exigent de bien gérer l’ordre de vie des objets.

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

Syntaxe

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 allocateur décrit un modèle d’allocation de mémoire. Dans std::vector<T, Allocator>, son type fait partie du type du conteneur ; par défaut, il s’agit de std::allocator<T>. std::allocator_traits<Allocator> fournit une interface uniforme pour l’allocation, la désallocation ainsi que la construction et la destruction des éléments. Obtenir de la mémoire n’est pas la même chose qu’appeler les constructeurs des éléments ; le conteneur gère normalement cette distinction.

std::pmr::memory_resource fournit une interface polymorphe qui alloue des blocs selon un nombre d’octets et un alignement. std::pmr::polymorphic_allocator<T> traduit les demandes concernant T vers cette interface. std::pmr::vector<T> utilise cet allocateur : deux vecteurs de ce type peuvent avoir le même type, mais des ressources différentes choisies à l’exécution. L’allocateur ne prend pas possession de la ressource.

std::pmr::monotonic_buffer_resource alloue successivement des parties d’un tampon ; une désallocation individuelle ne récupère rien. Quand l’espace est épuisé, la ressource amont est utilisée. Dans l’exemple, std::pmr::null_memory_resource() fait en sorte que cette demande déclenche std::bad_alloc au lieu d’obtenir de la mémoire supplémentaire. reserve(3) évite les réallocations lors des trois opérations push_back suivantes, mais la capacité exacte choisie dépend de l’implémentation.

Le tampon doit vivre plus longtemps que la ressource qui l’utilise, et la ressource plus longtemps que le conteneur. L’ordre des déclarations dans l’exemple garantit l’ordre de destruction inverse : values, resource, buffer. N’appelez pas release() tant que le conteneur a encore besoin de la mémoire allouée ; la libération de la ressource n’appelle pas les destructeurs des éléments stockés.

Cette fiche concerne C++23. L’URL fournie mène à un projet de norme évolutif, et non à une édition figée de C++23. Le code présenté a été exécuté sans modification dans un environnement isolé, et sa sortie standard correspondait exactement à la sortie indiquée. La vérification en production est distincte : ni ce test ni l’option de compilation du dépôt ne prouvent que l’exemple fonctionne dans cet environnement.

Exemples

#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';
}

Résultat

3
60

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources