Acessando Elementos

Parte da seção Lógica & Fluxo do Journey de C++ da Coddy — lição 12 de 56.

Agora que você sabe criar vetores e adicionar elementos a eles, você precisa saber como recuperar elementos específicos do seu vetor. O C++ fornece duas maneiras principais de acessar elementos individuais: o operador de colchetes e o método .at().

O operador de colchetes [] funciona exatamente como em arrays comuns. Você especifica o índice do elemento que deseja acessar:

std::vector<int> numbers = {10, 20, 30, 40};
int first = numbers[0];    // Obtém 10
int third = numbers[2];    // Obtém 30

O método .at() oferece uma forma alternativa de acessar elementos com uma diferença importante - ele inclui verificação de limites (bounds-checking):

int first = numbers.at(0);    // Obtém 10
int third = numbers.at(2);    // Obtém 30

A principal diferença é a segurança: se você tentar acessar um índice que não existe, [] pode causar comportamento imprevisível, enquanto .at() lançará uma exceção para alertá-lo sobre o erro. Para fins de aprendizado, ambos os métodos funcionam bem, mas .at() oferece proteção extra contra o acesso a posições inválidas em seu vetor.

Desafio

Fácil

Crie um programa que demonstre o acesso a elementos de um vetor recuperando elementos específicos de um vetor usando tanto o operador de colchetes quanto o método .at().

As seguintes entradas serão fornecidas:

Um número inteiro n representando o número de elementos no vetor
Em seguida, n inteiros para preencher o vetor
Um número inteiro index1 representando o primeiro índice a ser acessado
Um número inteiro index2 representando o segundo índice a ser acessado

Seu programa deve:

Criar um std::vector<int> chamado data
Usar push_back() para adicionar cada um dos n números de entrada ao vetor
Acessar o elemento no index1 usando o operador de colchetes [] e armazená-lo em uma variável chamada value1
Acessar o elemento no index2 usando o método .at() e armazená-lo em uma variável chamada value2
Imprimir os valores acessados e seus índices correspondentes
Imprimir o primeiro e o último elementos do vetor usando o acesso baseado em índice

Use o seguinte formato de saída exato:

Element at index [index1]: [value1]
Element at index [index2]: [value2]
First element: [first value]
Last element: [last value]

Para acessar o último elemento, use data.size() - 1 como o índice com o operador de colchetes.

Folha de consulta

Os vetores C++ fornecem duas maneiras principais de acessar elementos individuais:

Operador de colchetes []:

std::vector<int> numbers = {10, 20, 30, 40};
int first = numbers[0];    // Obtém 10
int third = numbers[2];    // Obtém 30

O método .at():

int first = numbers.at(0);    // Obtém 10
int third = numbers.at(2);    // Obtém 30

A principal diferença é a segurança: [] pode causar comportamento imprevisível se acessar índices inválidos, enquanto .at() lança uma exceção para proteção de verificação de limites.

Para acessar o último elemento, use data.size() - 1 como o índice.

Experimente você mesmo

#include <iostream>
#include <vector>
using namespace std;

int main() {
    // Ler entrada
    int n;
    cin >> n;
    
    vector<int> data;
    
    // Ler n inteiros e adicioná-los ao vetor
    for (int i = 0; i < n; i++) {
        int num;
        cin >> num;
        data.push_back(num);
    }
    
    int index1, index2;
    cin >> index1;
    cin >> index2;
    
    // TODO: Escreva seu código abaixo
    // Acesse os elementos usando o operador [] e o método .at()
    // Armazene os valores acessados em value1 e value2
    
    // Saída dos resultados
    cout << "Element at index " << index1 << ": " << value1 << endl;
    cout << "Element at index " << index2 << ": " << value2 << endl;
    cout << "First element: " << /* acessar o primeiro elemento */ << endl;
    cout << "Last element: " << /* acessar o último elemento usando data.size() - 1 */ << endl;
    
    return 0;
}