Ievads
Pateicoties to dinamiskajam izmēram un lietošanas vienkāršībai, vektori ir vienas no visbiežāk izmantotajām datu struktūrām C++. Tie nodrošina elastību un ātru elementu izgūšanu, ļaujot saglabāt un izgūt vienumus vienā blakus esošā atmiņas blokā. Šajā apmācībā jūs iegūsit pamatīgu izpratni par vektoru izmantošanu, jo mēs pētām vairākus veidus, kā piekļūt vektoru elementiem programmā C++.
1. Piekļuve elementiem pēc indeksa
To indeksu izmantošana ir viena no vienkāršākajām metodēm, kā iegūt piekļuvi vektora elementiem. Katram vektora elementam tiek piešķirts indekss, sākot no 0 pirmajam elementam un palielinot par 1 katram nākamajam elementam. Izmantojiet apakšindeksa operatoru [] un atbilstošo indeksu, lai izgūtu elementu noteiktā indeksā.
#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; } Izvade:
First Element: 10 Third Element: 30
2. Izmantojot at() Member funkciju
Funkcijas at() izmantošana ir vēl viens paņēmiens, kā iegūt vektora vienumus. Metode at() piedāvā robežu pārbaudi, lai pārliecinātos, ka nepiekļūstat elementiem, kas ir lielāki par vektoru. Ja tiek nodrošināts ārpus diapazona indekss, tiek izmests std::out_of_range izņēmums.
#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; } Izvade:
First Element: 10 Third Element: 30
3. Priekšējie un aizmugurējie elementi
Turklāt vektori piedāvā tiešu piekļuvi saviem pirmajiem un pēdējiem vienumiem, izmantojot attiecīgi dalībnieku metodes front() un rear(). Ja jums vienkārši nepieciešams piekļūt vektora galapunktiem, šīs funkcijas ir ļoti noderīgas.
#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; } Izvade:
First Element: 10 Last Element: 50
4. Iteratoru izmantošana
Iteratori ir spēcīgs rīks, lai pārvietotos un piekļūtu vienumiem konteineros, kurus nodrošina C++. Vektoru iteratoriem ir divas versijas: begin () un end (). End() iterators norāda vienu vietu aiz pēdējā elementa, savukārt sākuma() iterators norāda uz vektora sākuma locekli. Jūs varat piekļūt vektora vienumiem, atkārtojot to, izmantojot šos iteratorus.
#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; } Izvade:
10 20 30 40 50
5. Piekļuve elementiem, izmantojot diapazonā balstītu cilpu
C++11 tika ieviesta uz diapazonu balstīta cilpa, kas racionalizē iterācijas procesu, automātiski pārvaldot iteratorus. Neuzturot iteratorus, varat piekļūt vektora vienumiem, izmantojot šo funkcionalitāti.
#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; } Izvade:
10 20 30 40 50
6. Piekļuve elementiem, izmantojot rādītājus
Vektori tiek ieviesti C++ kā dinamiski izveidots masīvs, un, lai piekļūtu to elementiem, tiek izmantotas norādes. Funkciju data() var izmantot, lai iegūtu pirmā elementa atmiņas adresi, un rādītāja aritmētiku var izmantot, lai iegūtu secīgo vienumu adreses.
#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. Vektora izmēra pārbaude
Pirms mēģināt piekļūt kādam no tā elementiem, pārbaudiet, vai vektors nav tukšs. Izmantojiet izmēru() locekļa funkciju, lai noteiktu vektora izmēru. Piekļuve tukša vektora elementiem izraisīs neparedzētu uzvedību.
pilna summatora ķēde
#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; } Izvade:
10 20 30 40 50
8. Vektora elementu modificēšana
Ja jums ir piekļuve vektora elementiem, varat tos mainīt papildus to vērtību izgūšanai. Izmantojot jebkuru no piekļuves metodēm, jūs varat piešķirt vektora elementiem jaunas vērtības.
#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; } Izvade:
15 20 35 45 55
9. Ārpus diapazona piekļuves apstrāde
Izmantojot indeksus, lai piekļūtu vektora elementiem, ir ļoti svarīgi apstiprināt, ka indekss ietilpst pieņemamā diapazonā. Piekļuve vienumiem, kas ir lielāki par vektoru, izraisīs neparedzamu uzvedību. Rūpīgi veiciet nepieciešamo robežu pārbaudi, ja jums ir nepieciešams piekļūt vienumiem, pamatojoties uz aprēķiniem vai lietotāja ievadi, lai novērstu kļūdas.
#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())> Secinājums
Spēja piekļūt vektora elementiem programmā C++ ir būtiska darbam ar šo elastīgo datu formātu. Izpratne par dažādām pieejām, tostarp uz indeksu balstītu piekļuvi, iteratoriem, rādītājiem un diapazonā balstītu cilpu, ļaus jums droši iegūt un modificēt vektora vienumus, kā tas nepieciešams programmētājam. Lai novērstu iespējamās problēmas un nenosakāmu uzvedību, ņemiet vērā robežu pārbaudi, pievērsiet uzmanību vektora izmēram un ievērojiet piesardzību.