Función reserve de `<vector>` en C++

C++ 容器类 <vector>Clase de contenedor `<vector>` en C++


reservees la utilizada en vector parapreasignar memoriafunción importante que puede mejorar significativamente el rendimiento al agregar elementos.

reservees una función miembro de la clase contenedora, utilizada parareservar espacio de almacenamiento para al menos n elementos. Esto no cambia el tamaño (size) del contenedor, pero preasigna suficiente memoria para evitar reasignaciones frecuentes al agregar elementos posteriormente.

reservees la función clave para optimizar el rendimiento de vector, especialmente adecuada para escenarios donde se necesita agregar una gran cantidad de elementos.

Definición de la palabra: reserveSignifica "reservar", es decir, retener suficiente espacio de antemano.


Sintaxis básica y parámetros

reservees una función miembro de la clase contenedora, requiere especificar la cantidad de elementos a reservar.

Formato de sintaxis

void reserve(size_type n);

Descripción de parámetros

  • Parámetro: n
    • Tipo:size_type(tipo entero sin signo, normalmentesize_t)
    • Descripción: la cantidad mínima de elementos que deseas reservar. El contenedor asignará al menos espacio de memoria capaz de albergar n elementos.

Descripción de la función

  • Valor de retorno: void(sin valor de retorno).
  • Efecto: El contenedor reasignará memoria, de modo que su capacidad sea al menos n. Elsize()no cambiará, seguirá siendo la cantidad original de elementos.
  • Nota: Si n es menor que la capacidad actual,reserveno hará nada. Si n es mayor que la capacidad actual, reasignará memoria.

Ejemplo

A través de una serie de ejemplos, dominaremos completamentereserveel uso de.

Ejemplo 1: Uso básico - Preasignación de espacio

Ejemplo

#include <iostream>
#include <vector>

int main() {
    // Crear un vector vacío
    std::vector<int> numbers;

    std::cout << "Estado inicial - size: " << numbers.size()
              << ", capacity: " << numbers.capacity() << std::endl;

    // Reservar espacio para 100 elementos
    numbers.reserve(100);

    std::cout << "Después de reserve(100) - size: " << numbers.size()
              << ", capacity: " << numbers.capacity() << std::endl;

    // Agregar elementos
    for(int i = 0; i < 10; ++i) {
        numbers.push_back(i);
    }

    std::cout << "Después de agregar 10 elementos - size: " << numbers.size()
              << ", capacity: " << numbers.capacity() << std::endl;

    return 0;
}

Resultado esperado:

初始状态 - size: 0, capacity: 0
reserve(100) 后 - size: 0, capacity: 100
添加 10 个元素后 - size: 10, capacity: 100

Análisis del código:

  1. reserve(100)Se preasignó espacio de memoria capaz de contener 100 elementos.
  2. size()Sigue siendo 0, porque aún no se han agregado elementos.
  3. Después de agregar 10 elementos, la capacidad sigue siendo 100, no se realizó ninguna reasignación de memoria.

Ejemplo 2: Usar reserve para optimizar la adición de grandes cantidades de datos

Para escenarios donde se necesita agregar una gran cantidad de elementos, usar previamentereservepuede mejorar significativamente el rendimiento.

Ejemplo

#include <iostream>
#include <vector>
#include <chrono>

int main() {
    const int N = 100000;

    // Sin usar reserve
    std::vector<int> v1;
    auto start1 = std::chrono::high_resolution_clock::now();
    for(int i = 0; i < N; ++i) {
        v1.push_back(i);
    }
    auto end1 = std::chrono::high_resolution_clock::now();
    auto duration1 = std::chrono::duration_cast<std::chrono::microseconds>(end1 - start1);

    // Usando reserve
    std::vector<int> v2;
    v2.reserve(N);
    auto start2 = std::chrono::high_resolution_clock::now();
    for(int i = 0; i < N; ++i) {
        v2.push_back(i);
    }
    auto end2 = std::chrono::high_resolution_clock::now();
    auto duration2 = std::chrono::duration_cast<std::chrono::microseconds>(end2 - start2);

    std::cout << "Tiempo sin usar reserve: " << duration1.count() << " microsegundos" << std::endl;
    std::cout << "Tiempo usando reserve: " << duration2.count() << " microsegundos" << std::endl;
    std::cout << "Mejora de rendimiento: " << (double)duration1.count() / duration2.count() << "x" << std::endl;

    return 0;
}

Análisis del código:

  • Al agregar 100000 elementos, usar previamentereservepuede reducir significativamente el número de reasignaciones de memoria.
  • Esto puede traer una mejora notable de rendimiento al procesar grandes cantidades de datos.

Ejemplo 3: La forma correcta de usar reserve

Para aprovechar al máximoreservela función de, se debe estimar de antemano la capacidad necesaria.

Ejemplo

#include <iostream>
#include <vector>

int main() {
    // Supongamos que vamos a almacenar datos de 1000 usuarios
    struct User {
        std::string name;
        int age;
    };

    std::vector<User> users;
    users.reserve(1000); // Preasignar espacio

    // Simular la carga de datos de usuarios
    for(int i = 0; i < 1000; ++i) {
        User u;
        u.name = "Usuario" + std::to_string(i);
        u.age = 20 + (i % 50);
        users.push_back(u);
    }

    std::cout << "Número de usuarios: " << users.size() << std::endl;
    std::cout << "Capacidad: " << users.capacity() << std::endl;

    return 0;
}

Análisis del código:

  • Para la carga de datos de tamaño conocido, usar previamentereservees la mejor práctica.
  • Esto evita múltiples reasignaciones de memoria y mejora la eficiencia.

Ejemplo 4: Evitar reserve innecesario

reserveSe debe usar según las necesidades reales; la preasignación excesiva desperdicia memoria.

Ejemplo

#include <iostream>
<vector>

int main() {
    // Forma incorrecta: preasignación excesiva
    std::vector<int> v1;
    v1.reserve(1000000); // Solo se necesitan 10 elementos, ¡pero se preasignó espacio para 1 millón!

    for(int i = 0; i < 10; ++i) {
        v1.push_back(i);
    }

    std::cout << "Solo se necesitan 10 elementos - size: " << v1.size()
              << ", capacity: " << v1.capacity() << std::endl;

    // Forma correcta: preasignar según la necesidad
    std::vector<int> v2;
    v2.reserve(10);

    for(int i = 0; i < 10; ++i) {
        v2.push_back(i);
    }

    std::cout << "Se necesitan 10 elementos - size: " << v2.size()
              << ", capacity: " << v2.capacity() << std::endl;

    return 0;
}

Análisis del código:

  • La preasignación excesiva desperdicia espacio de memoria.
  • Se debe configurar según la cantidad real de elementos necesariosreserveel parámetro de.

Ejemplo 5: reserve y comprobación de capacidad

Se puede comprobar si la capacidad es suficiente antes de agregar elementos.

Ejemplo

#include <iostream>
#include <vector>

void addElements(std::vector<int>& v, int count) {
    // Si la capacidad actual no es suficiente, reservar espacio adecuado
    if(v.capacity() < v.size() + count) {
        v.reserve(v.size() + count);
    }

    // Agregar elementos
    for(int i = 0; i < count; ++i) {
        v.push_back(v.size());
    }
}

int main() {
    std::vector<int> data;

    std::cout << "Inicial - size: " << data.size()
              << ", capacity: " << data.capacity() << std::endl;

    addElements(data, 50);
    std::cout << "Después de agregar 50 - size: " << data.size()
              << ", capacity: " << data.capacity() << std::endl;

    addElements(data, 50);
    std::cout << "Después de agregar otros 50 - size: " << data.size()
              << ", capacity: " << data.capacity() << std::endl;

    return 0;
}

Análisis del código:

  • Se puede verificar dinámicamente y reservar capacidad dentro de la función.
  • Esto asegura que no ocurra reasignación de memoria al agregar elementos.

C++ 容器类 <vector>Clase de contenedor `<vector>` en C++

Otras extensiones