Dominando std::vector en C++: Arrays dinámicos, iteradores y ejemplos prácticos

¿Qué es un vector en C++?

Un vector de C++ es un array dinámico que se redimensiona automáticamente al agregar o eliminar elementos. Sus elementos se almacenan de forma contigua, permitiendo acceso indexado rápido y recorrido mediante iteradores.

La inserción ocurre al final en tiempo constante amortizado. Eliminar el último elemento también es tiempo constante, mientras que insertar o borrar al principio o en medio requiere desplazar elementos, resultando en complejidad lineal.

Cuándo usar un vector

• Cuando necesite un contenedor redimensionable para elementos que cambian con el tiempo.
• Cuando el tamaño final de la colección se desconoce en tiempo de compilación.

Cómo inicializar vectores en C++

std::vector<tipo_dato> nombre (tamaño, valor); // tamaño y valor son opcionales 

• tipo_dato especifica el tipo de elemento.
• nombre es el identificador del vector.
• El parámetro opcional tamaño reserva espacio; valor inicializa todos los elementos.

Iteradores

Los iteradores proporcionan una interfaz similar a punteros para elementos del vector. Funciones comunes de iteradores incluyen:

• begin() – primer elemento.
• end() – elemento pasado al final.
• cbegin() – iterador de solo lectura al primer elemento.
• cend() – iterador de solo lectura pasado al último elemento.

Modificadores

Los modificadores cambian el contenido del vector. Funciones clave son:

• push_back() – añade un elemento al final.
• insert() – inserta en posición especificada.
• pop_back() – elimina el último elemento.
• erase() – elimina un rango de elementos.
• clear() – elimina todos los elementos.

Ejemplo 1: Iteración básica

#include <iostream>
#include <vector>
int main() {
    std::vector<int> nums;
    for (int a = 1; a <= 5; ++a) {
        nums.push_back(a);
    }
    std::cout << "Salida desde begin y end: ";
    for (auto it = nums.begin(); it != nums.end(); ++it) {
        std::cout << *it << ' ';
    }
    std::cout << "\nSalida desde cbegin y cend: ";
    for (auto it = nums.cbegin(); it != nums.cend(); ++it) {
        std::cout << *it << ' ';
    }
    return 0;
}

Salida:

Ejemplo 2: Modificadores avanzados

#include <iostream>
#include <vector>
int main() {
    std::vector<int> nums;
    nums.assign(5, 1); // cinco elementos, todos inicializados a 1
    std::cout << "Contenido del vector: ";
    for (size_t i = 0; i < nums.size(); ++i) {
        std::cout << nums[i] << ' ';
    }
    nums.push_back(2);
    std::cout << "\nÚltimo elemento: " << nums.back();
    nums.pop_back();
    std::cout << "\nContenido del vector: ";
    for (int a : nums) std::cout << a << ' ';
    nums.insert(nums.begin(), 7);
    std::cout << "\nPrimer elemento: " << nums.front();
    nums.clear();
    std::cout << "\nTamaño tras clear(): " << nums.size();
    return 0;
}

Salida:

Funciones de capacidad

Determine y manipule las características de almacenamiento de un vector con las siguientes funciones:

• size() – número actual de elementos.
• max_size() – máximo teórico de elementos.
• capacity() – capacidad de almacenamiento asignada.
• resize(n) – cambia el número de elementos a n, añadiendo o eliminando según sea necesario.
• empty() – true si el vector no contiene elementos.

Ejemplo 3: Exploración de capacidad

#include <iostream>
#include <vector>
int main() {
    std::vector<int> vector1;
    for (int x = 1; x <= 10; ++x) {
        vector1.push_back(x);
    }
    std::cout << "Tamaño del vector: " << vector1.size() << std::endl;
    std::cout << "Capacidad del vector: " << vector1.capacity() << std::endl;
    std::cout << "Tamaño máximo del vector: " << vector1.max_size() << std::endl;
    vector1.resize(5);
    std::cout << "Tamaño tras redimensionar: " << vector1.size() << std::endl;
    if (!vector1.empty())
        std::cout << "El vector no está vacío" << std::endl;
    else
        std::cout << "El vector está vacío" << std::endl;
    return 0;
}

Salida:

Conclusiones clave

• Un vector de C++ es un contenedor altamente eficiente y automáticamente redimensionable.
• Los elementos residen en memoria contigua, proporcionando acceso aleatorio rápido.
• Inserción y eliminación al final son tiempo constante amortizado; al frente o medio son tiempo lineal.
• Los vectores son ideales para escenarios con tamaños de datos impredecibles o cambiantes.