Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

resize y reserve en std::vector y std::basic_string

`resize` cambia cuántos elementos existen; `reserve` prepara espacio para futuros elementos sin modificar el tamaño ni el contenido actual.

Versión: ISO C++23; implementation support may vary

Sintaxis

// 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);

En C++23, std::vector y std::basic_string distinguen el tamaño (size()) de la capacidad (capacity()). reserve(n) no cambia el tamaño ni el contenido. Si n > capacity(), se reasigna el almacenamiento y la nueva capacidad es al menos n; de lo contrario, la capacidad no cambia. El espacio reservado no amplía el rango de elementos accesibles. La sobrecarga sin argumentos std::basic_string::reserve() está obsoleta en C++23; std::vector no tiene esa sobrecarga.

Tras una llamada satisfactoria a resize(n) o resize(n, value), el tamaño es exactamente n. Reducir el tamaño elimina los últimos elementos; pedir el tamaño actual no modifica el contenido. Al crecer, std::vector::resize(n) añade elementos insertados por defecto según las reglas del asignador (ceros en std::vector<int> con su asignador estándar). La sobrecarga con dos argumentos añade copias de value sin sustituir los elementos existentes.

En std::basic_string, la sobrecarga con un argumento añade valores CharT() ('\0' para std::string), mientras que la de dos argumentos añade el carácter indicado. Los caracteres nulos añadidos cuentan para size(), pero las funciones que esperan una cadena de estilo C se detienen en el primer carácter nulo. En texto UTF-8, std::string cuenta bytes, no caracteres visibles; al truncar se puede cortar una secuencia de varios bytes.

La reasignación de un vector invalida todos los punteros, referencias e iteradores a sus elementos y el antiguo end(). No uses los que apuntaban a elementos eliminados. En una cadena, resize puede invalidarlos aunque la capacidad no cambie. Reducir el tamaño no garantiza que se libere memoria. En ambos tipos, reserve(n) lanza std::length_error si n > max_size(); también lo hace resize(n) en una cadena. La asignación de memoria o la construcción de elementos del vector también puede lanzar excepciones.

Ejemplos

#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

Tras reservar, ambos tamaños siguen siendo 2. En la línea `default`, `1` indica que el último carácter es `'\0'`. Las líneas siguientes muestran el relleno explícito y la reducción a un elemento.

Lecciones relacionadas

  • C++ · Lección 5 · Avanzado · Versión: 3

Fuentes