Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

std::pmr::vector: recursos de memória e alocadores dos elementos

Escolhe um recurso de memória para um vetor PMR e percebe quando os seus elementos recebem esse mesmo recurso e em que difere um vetor normal.

Versão: ISO C++23; implementation support may vary

Sintaxe

#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>, de <vector>, é um alias de std::vector<T, std::pmr::polymorphic_allocator<T>>, não uma classe de contentor distinta. std::pmr::string, de <string>, é std::basic_string para char com std::pmr::polymorphic_allocator<char>. Ambos os aliases e std::byte foram introduzidos em C++17 e fazem parte de C++23; o suporte pode variar consoante a implementação.

Um alocador polimórfico encaminha os pedidos de alocação para um std::pmr::memory_resource escolhido em tempo de execução. Com data{&arena}, escolhes explicitamente arena para o armazenamento dos elementos do vetor. Um alocador polimórfico construído por omissão obtém o recurso em vigor através de std::pmr::get_default_resource(). Isto não é o mesmo que std::allocator<T>, o tipo de alocador por omissão de um std::vector<T> normal.

Ao chamar emplace_back("PMR") num std::pmr::vector<std::pmr::string>, a construção que tem em conta o alocador passa o recurso do vetor à nova cadeia de caracteres. A cadeia usa-o se precisar de armazenamento separado para os caracteres. Se DATA designar std::pmr::string, um std::vector<DATA> normal continua a usar std::allocator<DATA> para armazenar os elementos. Nesta chamada não passa nenhum recurso ao construtor da cadeia, pelo que esta obtém o recurso PMR por omissão. Em contrapartida, uma std::string não passa a usar PMR só por ser um elemento de um vetor PMR.

std::byte, de <cstddef>, é um tipo enumerado com âmbito próprio cujo tipo subjacente é unsigned char. Um array deste tipo fornece aqui memória bruta a um std::pmr::monotonic_buffer_resource de <memory_resource>. Se um pedido não couber no espaço disponível, o recurso pede outro bloco ao recurso a montante. Se este for std::pmr::null_memory_resource(), o pedido lança std::bad_alloc.

O vetor não é proprietário do recurso. Declara o buffer, o recurso e o contentor por esta ordem para que o contentor seja destruído primeiro. Não chames release() enquanto houver objetos que dependam de memória alocada pelo recurso. Um recurso monótono não recupera espaço nas desalocações individuais.

Exemplos

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

Resultado

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

A asserção estática confirma o tipo de alocador do vetor normal. Os três resultados `true` confirmam a identidade dos recursos, não a alocação de memória para os caracteres: uma cadeia curta pode caber no seu próprio objeto.

Lições relacionadas

  • C++ · Lição 18 · Avançado · Versão: 3

Fontes