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

CKTIS / C++

std::basic_string::reserve — capacidad frente a tamaño

`reserve(n)` prepara espacio para futuros elementos sin cambiar cuántos hay. `resize(n)` cambia esa cantidad tanto en cadenas como en vectores.

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

Sintaxis

ISO C++23 member declarations (excerpts):

// <string>, in std::basic_string<CharT, Traits, Allocator>
constexpr void reserve(size_type n);
void reserve(); // Deprecated since C++20
constexpr void resize(size_type n);
constexpr void resize(size_type n, CharT c);

// <vector>, in std::vector<T, Allocator>
constexpr void reserve(size_type n);
constexpr void resize(size_type n);
constexpr void resize(size_type n, const T& value);

std::basic_string::reserve se declara en <string> y está disponible en std::string. En C++23, tras una llamada correcta a s.reserve(n), se cumple capacity() >= n; size() y el contenido no cambian. n es la capacidad total mínima, no el número de caracteres adicionales. Si n <= capacity(), no hay reasignación y la capacidad permanece igual. Si no, se reasigna el almacenamiento y la capacidad puede superar n.

std::vector::reserve(n), en <vector>, sigue la misma regla de capacidad sin crear elementos. La reasignación invalida los punteros, referencias e iteradores existentes a los elementos, así como el iterador de fin. Un vector garantiza que las inserciones posteriores no provocarán una reasignación hasta que una inserción supere la capacidad. No supongas que esa garantía se aplica a las operaciones que modifican una cadena.

Usa resize(n) cuando necesites exactamente n elementos: si reduces el tamaño, elimina elementos del final; si lo aumentas, añade nuevos. Las sobrecargas s.resize(n, c) y v.resize(n, value) rellenan las posiciones nuevas con el valor indicado. La capacidad sobrante no amplía el rango de índices de los elementos: escribe en ellos solo si i < size(). En una cadena, s[s.size()] se refiere al carácter nulo de terminación, no a un carácter adicional de la cadena.

std::basic_string::reserve(n) lanza std::length_error si n > max_size() y puede propagar excepciones del asignador, como std::bad_alloc. Si se lanza una excepción, la cadena no cambia. La sobrecarga distinta s.reserve() sin argumentos es una petición no vinculante de reducción de capacidad, obsoleta desde C++20 pero aún presente en C++23. Usa s.shrink_to_fit() para hacer esa petición; la reducción no está garantizada.

Ejemplos

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

int main() {
    std::string s = "hi";
    std::vector<int> v{1, 2};

    s.reserve(64);
    v.reserve(64);
    std::cout << std::boolalpha;
    std::cout << "string reserve: " << static_cast<unsigned int>(s.size()) << ' '
              << (s.capacity() >= 64) << ' ' << s << '\n';
    std::cout << "vector reserve: " << static_cast<unsigned int>(v.size()) << ' '
              << (v.capacity() >= 64) << ' ' << v[0] << ' ' << v[1] << '\n';

    s.resize(4, '!');
    v.resize(4, 9);
    std::cout << "string resize: " << static_cast<unsigned int>(s.size())
              << ' ' << s << '\n';
    std::cout << "vector resize: " << static_cast<unsigned int>(v.size())
              << ' ' << v[2] << ' ' << v[3] << '\n';
}

Resultado

string reserve: 2 true hi
vector reserve: 2 true 1 2
string resize: 4 hi!!
vector resize: 4 9 9

Tras `reserve(64)`, ambos contenedores siguen teniendo dos elementos. El programa solo comprueba el límite inferior de la capacidad; `resize` es lo que añade dos elementos a cada contenedor.

Lecciones relacionadas

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

Fuentes