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

CKTIS / C++

resize e reserve em std::vector e std::basic_string

`resize` altera o número de elementos existentes; `reserve` prepara espaço para elementos futuros sem mudar o tamanho nem o conteúdo atual.

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

Sintaxe

// Selected ISO C++23 member declarations, grouped by owning class.
// std::vector<T, Allocator> — <vector>
constexpr void reserve(size_type n);
constexpr void resize(size_type n);
constexpr void resize(size_type n, const T& value);

// std::basic_string<CharT, Traits, Allocator> — <string>
constexpr void reserve(size_type n);
constexpr void resize(size_type n);
constexpr void resize(size_type n, CharT ch);

Em C++23, std::vector e std::basic_string distinguem o tamanho (size()) da capacidade (capacity()). reserve(n) não altera o tamanho nem o conteúdo. Se n > capacity(), há uma realocação e a nova capacidade é pelo menos n; caso contrário, a capacidade mantém-se. O espaço reservado não aumenta o intervalo de elementos acessíveis. A sobrecarga sem argumentos std::basic_string::reserve() está desaconselhada em C++23; std::vector não tem essa sobrecarga.

Após uma chamada bem-sucedida a resize(n) ou resize(n, value), o tamanho é exatamente n. Reduzir o tamanho remove os últimos elementos; pedir o tamanho atual não altera o conteúdo. Ao crescer, std::vector::resize(n) acrescenta elementos inseridos por omissão segundo as regras do alocador (zeros em std::vector<int> com o seu alocador padrão). A sobrecarga com dois argumentos acrescenta cópias de value sem substituir os elementos existentes.

Em std::basic_string, a sobrecarga com um argumento acrescenta valores CharT() ('\0' para std::string) e a de dois argumentos acrescenta o carácter fornecido. Os caracteres nulos acrescentados contam para size(), mas as funções que esperam uma cadeia de caracteres ao estilo de C param no primeiro carácter nulo. Em texto UTF-8, std::string conta bytes, não caracteres visíveis; um corte pode dividir uma sequência de vários bytes.

A realocação de um vetor invalida todos os ponteiros, referências e iteradores para os seus elementos, bem como o antigo end(). Não utilizes os que apontavam para elementos removidos. Numa cadeia, resize pode invalidá-los mesmo que a capacidade não se altere. Reduzir o tamanho não garante a libertação de memória. Para ambos os tipos, reserve(n) lança std::length_error se n > max_size(); o mesmo se aplica a resize(n) numa cadeia. A alocação ou a construção de elementos do vetor também pode lançar exceções.

Exemplos

#include <iostream>
#include <string>
#include <vector>

int main() {
    std::vector<int> v{10, 20};
    std::string s = "ab";

    v.reserve(8);
    s.reserve(8);
    std::cout << "reserve: " << v.size() << ' ' << s.size() << '\n';

    v.resize(3);
    s.resize(3);
    std::cout << "default: " << v.back() << ' ' << (s.back() == '\0') << '\n';

    v.resize(5, 7);
    s.resize(5, '*');
    std::cout << "fill: " << v.back() << ' ' << s.back() << '\n';

    v.resize(1);
    s.resize(1);
    std::cout << "shrink: " << v.size() << ' ' << s.size()
              << " | " << v.front() << ' ' << s << '\n';
}

Resultado

reserve: 2 2
default: 0 1
fill: 7 *
shrink: 1 1 | 10 a

Após a reserva, ambos os tamanhos continuam a ser 2. Na linha `default`, `1` indica que o último carácter é `'\0'`. As linhas seguintes mostram o preenchimento explícito e a redução a um elemento.

Lições relacionadas

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

Fontes