Dominando std::vector em C++: Arrays Dinâmicos, Iteradores e Exemplos Práticos

O que é um Vector em C++?

Um vector C++ é um array dinâmico que se redimensiona automaticamente conforme elementos são adicionados ou removidos. Seus elementos são armazenados contiguamente, permitindo acesso indexado rápido e travessia via iteradores.

Inserção ocorre no final em tempo constante amortizado. Remover o último elemento também é tempo constante, enquanto inserir ou apagar no início ou meio requer deslocamento de elementos, resultando em complexidade de tempo linear.

Quando Usar um Vector?

• Quando você precisa de um container redimensionável para elementos que mudam ao longo do tempo.
• Quando o tamanho final da coleção é desconhecido em tempo de compilação.

Como Inicializar Vectors em C++

std::vector<tipo_dado> nome (tamanho, valor); // tamanho e valor são opcionais

• tipo_dado especifica o tipo do elemento.
• nome é o identificador do vector.
• O parâmetro opcional tamanho reserva espaço; valor inicializa todos os elementos.

Iteradores

Iteradores fornecem uma interface semelhante a ponteiro para elementos do vector. Funções de iterador comuns incluem:

• begin() – primeiro elemento.
• end() – elemento após o último (past-the-end).
• cbegin() – iterador somente leitura para o primeiro elemento.
• cend() – iterador somente leitura após o último elemento.

Modificadores

Modificadores alteram o conteúdo do vector. Funções principais são:

• push_back() – anexa um elemento.
• insert() – insere em posição especificada.
• pop_back() – remove o último elemento.
• erase() – apaga um intervalo de elementos.
• clear() – remove todos os elementos.

Exemplo 1: Iteração 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 << "Saída de begin e end: ";
    for (auto it = nums.begin(); it != nums.end(); ++it) {
        std::cout << *it << ' ';
    }
    std::cout << "\nSaída de cbegin e cend: ";
    for (auto it = nums.cbegin(); it != nums.cend(); ++it) {
        std::cout << *it << ' ';
    }
    return 0;
}

Saída:

Saída de begin e end: 1 2 3 4 5
Saída de cbegin e cend: 1 2 3 4 5

Exemplo 2: Modificadores Avançados

#include <iostream>
#include <vector>
int main() {
    std::vector<int> nums;
    nums.assign(5, 1); // cinco elementos, todos inicializados com 1
    std::cout << "Conteúdo do 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 << "\nConteúdo do vector: ";
    for (int a : nums) std::cout << a << ' ';
    nums.insert(nums.begin(), 7);
    std::cout << "\nPrimeiro elemento: " << nums.front();
    nums.clear();
    std::cout << "\nTamanho após clear(): " << nums.size();
    return 0;
}

Funções de Capacidade

Determine e manipule características de armazenamento de um vector com as seguintes funções:

• size() – número atual de elementos.
• max_size() – número teórico máximo de elementos.
• capacity() – capacidade de armazenamento alocada.
• resize(n) – altera número de elementos para n, adicionando ou removendo conforme necessário.
• empty() – true se o vector não contém elementos.

Exemplo 3: Exploração de Capacidade

#include <iostream>
#include <vector>
int main() {
    std::vector<int> vector1;
    for (int x = 1; x <= 10; ++x) {
        vector1.push_back(x);
    }
    std::cout << "Tamanho do vector: " << vector1.size() << std::endl;
    std::cout << "Capacidade do vector: " << vector1.capacity() << std::endl;
    std::cout << "Tamanho máximo do vector: " << vector1.max_size() << std::endl;
    vector1.resize(5);
    std::cout << "Tamanho do vector após redimensionar: " << vector1.size() << std::endl;
    if (!vector1.empty())
        std::cout << "Vector não está vazio" << std::endl;
    else
        std::cout << "Vector está vazio" << std::endl;
    return 0;
}

Principais Conclusões

• Um vector C++ é um container altamente eficiente e automaticamente redimensionável.
• Elementos residem em memória contígua, fornecendo acesso aleatório rápido.
• Inserção e remoção no final são tempo constante amortizado; no início ou meio são tempo linear.
• Vectors são ideais para cenários com tamanhos de dados imprevisíveis ou mutáveis.
• Prefira std::vector sobre arrays dinâmicos manuais (new[]/delete[]) para segurança e conveniência.