Introduction
En raison de leur taille dynamique et de leur simplicité d’utilisation, les vecteurs font partie des structures de données les plus fréquemment utilisées en C++. Ils vous offrent flexibilité et récupération rapide des éléments en vous permettant de stocker et de récupérer des éléments dans un seul bloc de mémoire contigu. Vous comprendrez parfaitement comment utiliser les vecteurs dans ce didacticiel en étudiant plusieurs façons d'accéder aux éléments vectoriels en C++.
1. Accéder aux éléments par index
L'utilisation de leurs indices est l'une des méthodes les plus simples pour accéder aux éléments vectoriels. Un index est attribué à chaque élément d'un vecteur, commençant à 0 pour le premier élément et augmentant de 1 pour chaque autre membre. Utilisez l'opérateur d'indice [] et l'index approprié pour récupérer un élément à un index donné.
#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; } Sortir:
First Element: 10 Third Element: 30
2. Utilisation de la fonction membre at()
L’utilisation de la fonction membre at() est une autre technique pour accéder aux éléments vectoriels. La méthode at() propose une vérification des limites pour vous assurer que vous n'accédez pas à des éléments plus grands que le vecteur. Une exception std::out_of_range est levée si un index hors plage est fourni.
#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; } Sortir:
First Element: 10 Third Element: 30
3. Éléments avant et arrière
De plus, les vecteurs offrent un accès direct à leurs premier et dernier éléments via les méthodes membres front() et Rear(), respectivement. Lorsque vous avez simplement besoin d'accéder aux extrémités du vecteur, ces fonctions sont très utiles.
#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; } Sortir:
First Element: 10 Last Element: 50
4. Utiliser des itérateurs
Les itérateurs sont un outil puissant pour naviguer et accéder aux éléments dans les conteneurs fournis par C++. Les itérateurs pour les vecteurs sont disponibles en deux versions : start() et end(). L'itérateur end() pointe une place après le dernier élément, tandis que l'itérateur start() pointe vers le membre de début du vecteur. Vous pouvez accéder aux éléments du vecteur en itérant dessus à l'aide de ces itérateurs.
#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; } Sortir:
10 20 30 40 50
5. Accès aux éléments avec une boucle for basée sur une plage
La boucle for basée sur une plage, qui rationalise le processus d'itération en gérant automatiquement les itérateurs, a été introduite en C++11. Sans maintenir explicitement les itérateurs, vous pouvez accéder aux éléments vectoriels en utilisant cette fonctionnalité.
#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; } Sortir:
10 20 30 40 50
6. Accéder aux éléments à l'aide de pointeurs
Les vecteurs sont implémentés en C++ sous la forme d'un tableau créé dynamiquement et des pointeurs sont utilisés pour accéder à leurs éléments. La fonction membre data() peut être utilisée pour obtenir l'adresse mémoire du premier élément, et l'arithmétique du pointeur peut être utilisée pour obtenir les adresses des éléments successifs.
#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. Vérification de la taille du vecteur
Vérifiez que le vecteur n'est pas vide avant de tenter d'accéder à l'un de ses éléments. Utilisez la fonction membre size() pour déterminer la taille d’un vecteur. L'accès aux éléments d'un vecteur vide entraînera un comportement inattendu.
python __nom__
#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; } Sortir:
10 20 30 40 50
8. Modification des éléments vectoriels
Lorsque vous avez accès aux éléments vectoriels, vous pouvez les modifier en plus de récupérer leurs valeurs. En utilisant n’importe quelle technique d’accès, vous pouvez attribuer de nouvelles valeurs aux éléments vectoriels.
#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; } Sortir:
15 20 35 45 55
9. Gestion des accès hors de portée
Lorsque vous utilisez des indices pour accéder à des éléments vectoriels, il est crucial de confirmer que l'indice se situe dans la plage acceptable. L'accès à des éléments plus grands que le vecteur entraînera un comportement imprévisible. Veillez à effectuer les limites nécessaires en vérifiant si vous devez accéder aux éléments en fonction de calculs ou de saisies utilisateur pour éviter toute erreur.
#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())> Conclusion
La possibilité d'accéder aux éléments vectoriels en C++ est essentielle pour travailler avec ce format de données flexible. Comprendre les différentes approches, y compris l'accès basé sur l'index, les itérateurs, les pointeurs et la boucle for basée sur la plage, vous permettra d'obtenir et de modifier de manière fiable les éléments vectoriels selon les besoins de votre programmeur. Pour éviter des problèmes probables et des comportements indéfinissables, n'oubliez pas de gérer la vérification des limites, de prendre soin de la taille du vecteur et de faire preuve de prudence.