Introdução
Devido ao seu tamanho dinâmico e simplicidade de uso, os vetores estão entre as estruturas de dados usadas com mais frequência em C++. Eles fornecem flexibilidade e recuperação rápida de elementos, permitindo armazenar e recuperar itens em um único bloco de memória contíguo. Você terá uma compreensão completa de como usar vetores neste tutorial enquanto estudamos várias maneiras de acessar elementos vetoriais em C++.
1. Acessando Elementos por Índice
Utilizar seus índices está entre os métodos mais fáceis de obter acesso a elementos vetoriais. Um índice é atribuído a cada elemento de um vetor, começando em 0 para o primeiro elemento e aumentando em 1 para cada membro adicional. Use o operador subscrito [] e o índice apropriado para recuperar um elemento em um determinado índice.
#include #include int main() { std::vector numbers = {10, 20, 30, 40, 50}; int firstElement = numbers[0]; // Accessing the first element int thirdElement = numbers[2]; // Accessing the third element std::cout << 'First Element: ' << firstElement << std::endl; std::cout << 'Third Element: ' << thirdElement << std::endl; return 0; } Saída:
First Element: 10 Third Element: 30
2. Usando a função de membro at()
Usar a função membro at() é outra técnica para obter itens vetoriais. O método at() oferece verificação de limites para garantir que você não acesse elementos maiores que o vetor. Uma exceção std::out_of_range será lançada se um índice fora do intervalo for fornecido.
#include #include int main() { std::vector numbers = {10, 20, 30, 40, 50}; int firstElement = numbers.at(0); // Accessing the first element int thirdElement = numbers.at(2); // Accessing the third element std::cout << 'First Element: ' << firstElement << std::endl; std::cout << 'Third Element: ' << thirdElement << std::endl; return 0; } Saída:
First Element: 10 Third Element: 30
3. Elementos frontais e traseiros
Além disso, os vetores oferecem acesso direto ao primeiro e ao último item por meio dos métodos membros front() e rear(), respectivamente. Quando você simplesmente precisa acessar os pontos finais do vetor, essas funções são bastante úteis.
#include #include int main() { std::vector numbers = {10, 20, 30, 40, 50}; int firstElement = numbers.front(); // Accessing the first element int lastElement = numbers.back(); // Accessing the last element std::cout << 'First Element: ' << firstElement << std::endl; std::cout << 'Last Element: ' << lastElement << std::endl; return 0; } Saída:
First Element: 10 Last Element: 50
4. Usando Iteradores
Iteradores são uma ferramenta poderosa para navegar e obter acesso a itens em contêineres fornecidos por C++. Iteradores para vetores vêm em dois tipos: início() e fim(). O iterador end() aponta um lugar após o último elemento, enquanto o iterador begin() aponta para o membro inicial do vetor. Você pode acessar os itens do vetor iterando sobre ele usando esses iteradores.
#include #include int main() { std::vector numbers = {10, 20, 30, 40, 50}; // Accessing elements using iterators for (auto it = numbers.begin(); it != numbers.end(); ++it) { int element = *it; // Process the element std::cout << element << ' '; } std::cout << std::endl; return 0; } Saída:
10 20 30 40 50
5. Acessando elementos com loop for baseado em intervalo
O loop for baseado em intervalo, que agiliza o processo de iteração gerenciando automaticamente os iteradores, foi introduzido no C++ 11. Sem manter iteradores explicitamente, você pode acessar itens de vetor usando esta funcionalidade.
#include #include int main() { std::vector numbers = {10, 20, 30, 40, 50}; // Accessing elements using a range-based for loop for (int element : numbers) { // Process the element std::cout << element << ' '; } std::cout << std::endl; return 0; } Saída:
10 20 30 40 50
6. Acessando elementos usando ponteiros
Os vetores são implementados em C++ como um array criado dinamicamente e ponteiros são usados para acessar seus elementos. A função membro data() pode ser usada para obter o endereço de memória do primeiro elemento, e a aritmética de ponteiro pode ser usada para obter os endereços de itens sucessivos.
#include #include int main() { std::vector numbers = {10, 20, 30, 40, 50}; // Accessing elements using pointers int* ptr = numbers.data(); // Get the pointer to the first element for (size_t i = 0; i <numbers.size(); ++i) { int element="*(ptr" + i); process the std::cout << ' '; } std::endl; return 0; < pre> <p> <strong>Output:</strong> </p> <pre> 10 20 30 40 50 </pre> <p> <strong>7. Checking Vector Size</strong> </p> <p>Verify that the vector is not empty before attempting to access any of its elements. Use the size() member function to determine a vector's size. Accessing the elements of an empty vector will result in unexpected behavior.</p> <pre> #include #include int main() { std::vector numbers = {10, 20, 30, 40, 50}; if (!numbers.empty()) { // Access vector elements for (int element : numbers) { std::cout << element << ' '; } std::cout << std::endl; } else { std::cout << 'Vector is empty.' << std::endl; } return 0; } </pre> <p> <strong>Output:</strong> </p> <pre> 10 20 30 40 50 </pre> <p> <strong>8. Modifying Vector Elements</strong> </p> <p>When you have access to vector elements, you may change them in addition to retrieving their values. Using any of the access techniques, you may give vector elements new values.</p> <pre> #include #include int main() { std::vector numbers = {10, 20, 30, 40, 50}; numbers[2] = 35; // Modifying an element using index numbers.at(3) = 45; // Modifying an element using at() // Modifying the first and last elements numbers.front() = 15; numbers.back() = 55; // Printing the modified vector for (int element : numbers) { std::cout << element << ' '; } std::cout << std::endl; return 0; } </pre> <p> <strong>Output:</strong> </p> <pre> 15 20 35 45 55 </pre> <p> <strong>9. Handling Out-of-Range Access</strong> </p> <p>When utilizing indices to access vector elements, it's crucial to confirm that the index falls within the acceptable range. Accessing items that are larger than the vector will lead to unpredictable behavior. Make careful to carry out the necessary bounds checking if you need to access items based on computations or user input to prevent any mistakes.</p> <pre> #include #include // Function to get user input size_t getUserInput() { size_t index; std::cout <> index; return index; } int main() { std::vector numbers = {10, 20, 30, 40, 50}; size_t index = getUserInput(); if (index <numbers.size()) { int element="numbers[index];" process the std::cout << 'element at index ' ': std::endl; } else handle out-of-range access 'invalid index. out of range.' return 0; < pre> <p> <strong>Output:</strong> </p> <pre> Enter the index: 2 Element at index 2: 30 </pre> <h3>Conclusion</h3> <p>The ability to access vector elements in C++ is essential for working with this flexible data format. Understanding the different approaches-including index-based access, iterators, pointers, and the range-based for loop-will enable you to reliably obtain and modify vector items as needed for your programmer. To prevent probable problems and undefinable behavior, bear in mind to handle bounds checking, care for vector size, and apply prudence.</p> <hr></numbers.size())></pre></numbers.size();> 7. Verificando o tamanho do vetor
Verifique se o vetor não está vazio antes de tentar acessar qualquer um de seus elementos. Use a função membro size() para determinar o tamanho de um vetor. Acessar os elementos de um vetor vazio resultará em um comportamento inesperado.
Freddie Mercury
#include #include int main() { std::vector numbers = {10, 20, 30, 40, 50}; if (!numbers.empty()) { // Access vector elements for (int element : numbers) { std::cout << element << ' '; } std::cout << std::endl; } else { std::cout << 'Vector is empty.' << std::endl; } return 0; } Saída:
10 20 30 40 50
8. Modificando elementos vetoriais
Ao ter acesso aos elementos do vetor, você pode alterá-los além de recuperar seus valores. Usando qualquer uma das técnicas de acesso, você pode atribuir novos valores aos elementos do vetor.
#include #include int main() { std::vector numbers = {10, 20, 30, 40, 50}; numbers[2] = 35; // Modifying an element using index numbers.at(3) = 45; // Modifying an element using at() // Modifying the first and last elements numbers.front() = 15; numbers.back() = 55; // Printing the modified vector for (int element : numbers) { std::cout << element << ' '; } std::cout << std::endl; return 0; } Saída:
15 20 35 45 55
9. Lidando com acesso fora do alcance
Ao utilizar índices para acessar elementos vetoriais, é crucial confirmar se o índice está dentro do intervalo aceitável. Acessar itens maiores que o vetor levará a um comportamento imprevisível. Tenha o cuidado de realizar a verificação de limites necessária se precisar acessar itens com base em cálculos ou entradas do usuário para evitar erros.
#include #include // Function to get user input size_t getUserInput() { size_t index; std::cout <> index; return index; } int main() { std::vector numbers = {10, 20, 30, 40, 50}; size_t index = getUserInput(); if (index <numbers.size()) { int element="numbers[index];" process the std::cout << \'element at index \' \': std::endl; } else handle out-of-range access \'invalid index. out of range.\' return 0; < pre> <p> <strong>Output:</strong> </p> <pre> Enter the index: 2 Element at index 2: 30 </pre> <h3>Conclusion</h3> <p>The ability to access vector elements in C++ is essential for working with this flexible data format. Understanding the different approaches-including index-based access, iterators, pointers, and the range-based for loop-will enable you to reliably obtain and modify vector items as needed for your programmer. To prevent probable problems and undefinable behavior, bear in mind to handle bounds checking, care for vector size, and apply prudence.</p> <hr></numbers.size())> Conclusão
A capacidade de acessar elementos vetoriais em C++ é essencial para trabalhar com esse formato de dados flexível. Compreender as diferentes abordagens - incluindo acesso baseado em índice, iteradores, ponteiros e o loop for baseado em intervalo - permitirá que você obtenha e modifique itens de vetor de maneira confiável, conforme necessário para seu programador. Para evitar problemas prováveis e comportamento indefinível, lembre-se de lidar com a verificação de limites, cuidar do tamanho do vetor e aplicar prudência.