Introduksjon
På grunn av deres dynamiske størrelse og enkle bruk, er vektorer blant de mest brukte datastrukturene i C++. De gir deg fleksibilitet og rask gjenfinning av elementer ved at du kan lagre og hente gjenstander i en enkelt, sammenhengende minneblokk. Du vil få en grundig forståelse av hvordan du bruker vektorer i denne opplæringen når vi studerer flere måter å få tilgang til vektorelementer i C++.
1. Få tilgang til elementer etter indeks
Å bruke indeksene deres er blant de enkleste metodene for å få tilgang til vektorelementer. En indeks er tilordnet hvert element i en vektor, som starter ved 0 for det første elementet og øker med 1 for hvert ytterligere medlem. Bruk subscript-operatoren [] og den aktuelle indeksen for å hente et element ved en gitt 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; } Produksjon:
First Element: 10 Third Element: 30
2. Bruke at()-medlemsfunksjonen
Å bruke at()-medlemsfunksjonen er en annen teknikk for å komme til vektorelementer. Metoden at() tilbyr grensekontroll for å sikre at du ikke får tilgang til elementer som er større enn vektoren. Et std::out_of_range-unntak blir kastet hvis en indeks utenfor rekkevidde leveres.
#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; } Produksjon:
First Element: 10 Third Element: 30
3. Front- og bakelementer
I tillegg tilbyr vektorer direkte tilgang til deres første og siste elementer via medlemsmetodene henholdsvis front() og rear(). Når du bare trenger å få tilgang til vektorens endepunkter, er disse funksjonene ganske nyttige.
#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; } Produksjon:
First Element: 10 Last Element: 50
4. Bruke iteratorer
Iteratorer er et potent verktøy for å navigere og få tilgang til elementer i beholdere som leveres av C++. Iteratorer for vektorer kommer i to varianter: begin() og end(). End()-iteratoren peker ett sted etter det siste elementet, mens begin()-iteratoren peker på startmedlemmet til vektoren. Du kan få tilgang til elementene i vektoren ved å iterere over den ved å bruke disse iteratorene.
#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; } Produksjon:
10 20 30 40 50
5. Tilgang til elementer med rekkeviddebasert for sløyfe
Den rekkeviddebaserte for loop, som effektiviserer iterasjonsprosessen ved automatisk å administrere iteratorer, ble introdusert i C++11. Uten å eksplisitt vedlikeholde iteratorer, kan du få tilgang til vektorelementer ved å bruke denne funksjonaliteten.
#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; } Produksjon:
10 20 30 40 50
6. Få tilgang til elementer ved hjelp av pekere
Vektorer er implementert i C++ som en dynamisk opprettet matrise, og pekere brukes for å få tilgang til elementene deres. Data()-medlemsfunksjonen kan brukes til å få minneadressen til det første elementet, og pekeraritmetikk kan brukes til å få adressene til påfølgende elementer.
#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. Kontrollere vektorstørrelse
Kontroller at vektoren ikke er tom før du prøver å få tilgang til noen av elementene. Bruk size()-medlemsfunksjonen for å bestemme størrelsen til en vektor. Å få tilgang til elementene i en tom vektor vil resultere i uventet oppførsel.
1 til 100 romersk nr
#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; } Produksjon:
10 20 30 40 50
8. Endre vektorelementer
Når du har tilgang til vektorelementer, kan du endre dem i tillegg til å hente verdiene deres. Ved å bruke hvilken som helst av tilgangsteknikkene kan du gi vektorelementer nye verdier.
#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; } Produksjon:
15 20 35 45 55
9. Håndtering av tilgang utenfor rekkevidde
Når du bruker indekser for å få tilgang til vektorelementer, er det avgjørende å bekrefte at indeksen faller innenfor det akseptable området. Å få tilgang til elementer som er større enn vektoren vil føre til uforutsigbar atferd. Vær nøye med å utføre den nødvendige grensekontrollen hvis du trenger tilgang til elementer basert på beregninger eller brukerinndata for å forhindre feil.
#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())> Konklusjon
Evnen til å få tilgang til vektorelementer i C++ er avgjørende for å jobbe med dette fleksible dataformatet. Å forstå de forskjellige tilnærmingene – inkludert indeksbasert tilgang, iteratorer, pekere og rekkeviddebaserte for loop – vil gjøre deg i stand til pålitelig å skaffe og modifisere vektorelementer etter behov for programmereren din. For å forhindre sannsynlige problemer og udefinerbar oppførsel, husk å håndtere grensekontroll, ta vare på vektorstørrelse og bruke forsiktighet.