Notice: This page requires JavaScript to function properly.
Please enable JavaScript in your browser settings or update your browser.Leer Dereferencing and Incrementing | Iterator Fundamentals
C++ STL Iterators

bookDereferencing and Incrementing

Veeg om het menu te tonen

Iterators use the dereferencing operator (*) to access the value they point to, similar to pointers. The member access operator (->) is used when the element is an object, allowing access to its members.

Iterators are advanced using increment operators. Prefix increment (++it) moves to the next element and returns the updated iterator, while postfix increment (it++) returns the old value before advancing. Prefix increment is generally preferred because it can be more efficient.

main.cpp

main.cpp

copy

              
1234567891011121314151617181920212223242526272829303132

            
#include <iostream>
#include <deque>

struct Point {
    int x, y;
    void print() const { std::cout << "(" << x << ", " << y << ")\n"; }
};

int main()
{
    std::deque<Point> points = {{1, 2}, {3, 4}, {5, 6}};

    auto it = points.begin();

    // Access element using *
    std::cout << "First element: ";
    (*it).print();

    // Access member using ->
    std::cout << "First element via ->: ";
    it->print();

    // Prefix increment
    ++it;
    std::cout << "After prefix ++it, element: ";
    it->print();

    // Postfix increment
    it++;
    std::cout << "After postfix it++, element: ";
    it->print();
}

In the code above, both dereferencing and member access are used. (*it).print() and it->print() call the print method on the object the iterator points to and are functionally equivalent. Prefix increment (++it) advances the iterator before it is used, while postfix increment (it++) advances it after returning the current value. For simple cases they behave similarly, but for more complex iterators, prefix increment is usually more efficient. Use *it to access the element itself and it->member to access one of its members.

main.cpp

main.cpp

copy

              
12345678910111213141516171819

            
#include <iostream>
#include <vector>

int main()
{
    std::vector<int> numbers = {10, 20, 30};
    auto it = numbers.end(); // Points one past the last element

    // Mistake: Dereferencing end() is undefined behavior
    // std::cout << *it << "\n"; // Uncommenting this line is dangerous!

    // Mistake: Incrementing past end()
    ++it; // Now it is beyond valid range

    // Even more dangerous to dereference now
    // std::cout << *it << "\n"; // Still undefined behavior

    std::cout << "Avoid dereferencing or incrementing past end().\n";
}

A common mistake with iterators is incrementing past the end of a container or dereferencing the iterator returned by end(). Since end() points just past the last element, using *end() or incrementing it results in undefined behavior. Always ensure an iterator is not equal to end() before dereferencing or advancing it. The earlier example follows this rule, keeping iteration within the valid range and safely using *, ->, and increment operators.

Note
Note

For some iterator types, especially those that are not simple pointers, prefix increment (++it) is more efficient than postfix increment (it++) because postfix may create a temporary copy of the iterator. In performance-critical code, prefer prefix increment unless the previous value is required.

question mark

Which operator is used to access the value pointed to by an iterator?

Select the correct answer

Was alles duidelijk?

Hoe kunnen we het verbeteren?

Bedankt voor je feedback!

Sectie 1. Hoofdstuk 3

Vraag AI

expand

Vraag AI

ChatGPT

Vraag wat u wilt of probeer een van de voorgestelde vragen om onze chat te starten.

Sectie 1. Hoofdstuk 3
some-alt