Clase de contenedor C++<vector>

Introducción

La biblioteca estándar de C++ (Standard Template Library, STL) es una parte importante de C++, que proporciona un conjunto de clases y funciones de plantillas genéricas para manejar colecciones de datos.<vector>Es una clase de contenedor en STL, utilizada para almacenar arreglos de tamaño dinámico.

<vector>Es un contenedor secuencial que permite a los usuarios agregar o eliminar elementos rápidamente al final del contenedor. En comparación con los arreglos,<vector>proporciona más funcionalidades, como ajuste automático de tamaño, acceso aleatorio, etc.

Sintaxis

En C++, para usar<vector>es necesario incluir el archivo de encabezado<<vector>>. A continuación se muestra una sintaxis básica:

  • Declarar unvector：

    std::vector<int> myVector;

  • Agregar elementos:

    myVector.push_back(10);

  • Acceder a elementos:

    int firstElement = myVector[0];

  • Obtener la cantidad de elementos:

    size_t size = myVector.size();

  • Vaciarvector：

    myVector.clear();

Declaración e inicialización

<vector>Es necesario especificar el tipo de elemento; se puede inicializar de múltiples formas:

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec1;                  // 空的vector
    std::vector<int> vec2(5);               // 长度为5的vector，元素默认初始化
    std::vector<int> vec3(5, 10);           // 长度为5的vector，元素值为10
    std::vector<int> vec4 = {1, 2, 3, 4};   // 使用初始化列表初始化

    return 0;
}

Ejemplo

A continuación se muestra el uso de<vector>en un ejemplo sencillo, incluyendo el resultado de salida.

Ejemplo

#include <iostream>
#include <vector>

int main() {
    // Declarar un vector que almacena enteros
    std::vector<int> numbers;

    // Agregar elementos
    numbers.push_back(10);
    numbers.push_back(20);
    numbers.push_back(30);

    // Mostrar los elementos del vector
    std::cout << "Vector contains: ";
    for (int i = 0; i < numbers.size(); ++i) {
        std::cout << numbers[i] << " ";
    }
    std::cout << std::endl;

    // Agregar más elementos
    numbers.push_back(40);
    numbers.push_back(50);

    // Mostrar nuevamente los elementos del vector
    std::cout << "After adding more elements, vector contains: ";
    for (int i = 0; i < numbers.size(); ++i) {
        std::cout << numbers[i] << " ";
    }
    std::cout << std::endl;

    // Acceder a un elemento específico
    std::cout << "The first element is: " << numbers[0] << std::endl;

    // Vaciar el vector
    numbers.clear();

    // Comprobar si el vector está vacío
    if (numbers.empty()) {
        std::cout << "The vector is now empty." << std::endl;
    }

    return 0;
}

Resultado de salida:

Vector contains: 10 20 30 
After adding more elements, vector contains: 10 20 30 40 50 
The first element is: 10 
The vector is now empty.

Funciones miembro comunes

A continuación se presentan<vector>algunas funciones miembro comunes en:

Función Descripción
push_back(const T& val) Agregar un elemento al final
pop_back() Eliminar el elemento del final
at(size_t pos) Devuelve el elemento en la posición especificada, con comprobación de límites
operator[] Devuelve el elemento en la posición especificada, sin comprobación de límites
front() Devuelve el primer elemento
back() Devuelve el último elemento
data() Devuelve un puntero al arreglo subyacente
size() Devuelve el número actual de elementos
capacity() Devuelve la capacidad actualmente asignada
reserve(size_t n) Reservar al menosnespacio de almacenamiento para elementos
resize(size_t n) Ajustar el número de elementos an
clear() Elimina todos los elementos
insert(iterator pos, val) Insertar un elemento en la posición especificada
erase(iterator pos) Eliminar el elemento en la posición especificada
begin() / end() Devuelve los iteradores de inicio/fin

Ejemplo

1. Operaciones básicas

Ejemplo

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // Mostrar todos los elementos
    std::cout << "Vector elements: ";
    for (int i = 0; i < vec.size(); ++i) {
        std::cout << vec[i] << " ";
    }
    std::cout << std::endl;

    // Obtener el primer y el último elemento
    std::cout << "First element: " << vec.front() << std::endl;
    std::cout << "Last element: " << vec.back() << std::endl;

    return 0;
}

2. Agregar y eliminar elementos dinámicamente

Ejemplo

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec;
    vec.push_back(10);
    vec.push_back(20);
    vec.push_back(30);

    std::cout << "Vector size: " << vec.size() << std::endl;
    std::cout << "Vector capacity: " << vec.capacity() << std::endl;

    // Eliminar el último elemento
    vec.pop_back();
    std::cout << "After pop_back, size: " << vec.size() << std::endl;

    return 0;
}

3. Comprobación de límites y acceso seguro

Ejemplo

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec = {1, 2, 3};

    try {
        std::cout << vec.at(2) << std::endl;  // Salida normal
        std::cout << vec.at(5) << std::endl;  // Fuera de rango, lanza una excepción
    } catch (const std::out_of_range& e) {
        std::cout << "Exception: " << e.what() << std::endl;
    }

    return 0;
}

4. Preasignación de capacidad

Ejemplo

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec;
    vec.reserve(10);  // Reservar capacidad para evitar asignaciones frecuentes de memoria

    for (int i = 0; i < 10; ++i) {
        vec.push_back(i);
        std::cout << "Capacity after push_back(" << i << "): " << vec.capacity() << std::endl;
    }

    return 0;
}

Comparación con otros contenedores

Característicastd::vectorstd::arraystd::list
TamañoVariable dinámicamenteFijo en tiempo de compilaciónVariable dinámicamente
Ubicación de almacenamientoMemoria contiguaMemoria contiguaMemoria no contigua
Rendimiento de accesoAcceso aleatorio rápidoAcceso aleatorio rápidoAcceso aleatorio lento, adecuado para acceso secuencial
Rendimiento de inserción y eliminaciónAlto rendimiento en operaciones al final, más lento en otras posicionesNo soportadoInserción y eliminación rápidas en cualquier posición
Forma de crecimiento de la memoriaCrece en múltiplos cuando la capacidad es insuficienteNingunoNinguno

<vector>Es un contenedor muy útil en C++ STL, que proporciona la funcionalidad de arreglos dinámicos, haciendo que la adición y eliminación de elementos sea más flexible y conveniente. A través de los ejemplos anteriores, los principiantes pueden comprender rápidamente<vector>el uso básico y las operaciones. A medida que profundices en el aprendizaje, descubrirás<vector>la potente funcionalidad y la amplia aplicación en la programación real.

Otras extensiones