[2026] C++ iterator | Iterator Complete Guide

Iterator Basics

Iterator is an object that iterates over container elements. It is used as begin/end in range-based for and vector, and is often used when dealing with distance and index with size_t·ptrdiff_t and when unifying tree traversal with Composite pattern I write.

Iterator concept diagram

아래 코드는 mermaid를 사용한 구현 예제입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

graph LR
    A[Container] --> B[begin]
    A --> C[end]
    B --> D[Iter]
    D -->|++| E[Iter]
    E -->|++| F[Iter]
    F -->|++| C
    
    D -->|*| G[Elem 1]
    E -->|*| H[Elem 2]
    F -->|*| I[Elem 3]

다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 반복문으로 데이터를 처리합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

#include <vector>
using namespace std;
int main() {
    vector<int> v = {1, 2, 3, 4, 5};
    
    // begin/end
    for (auto it = v.begin(); it != v.end(); ++it) {
        cout << *it << " ";
    }
    cout << endl;
    
    // 역방향
    for (auto it = v.rbegin(); it != v.rend(); ++it) {
        cout << *it << " ";  // 5 4 3 2 1
    }
}
```## Iterator type
### Iterator Hierarchy
아래 코드는 mermaid를 사용한 구현 예제입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
```mermaid
graph TD
    A[Input Iterator] --> C[Forward Iterator]
    B[Output Iterator] --> C
    C --> D[Bidirectional Iterator]
    D --> E[Random Access Iterator]
    E --> F[Contiguous Iterator C++20]
    
    A -.->|읽기 전용| A1[istream_iterator]
    B -.->|쓰기 전용| B1[ostream_iterator]
    C -.->|단방향| C1[forward_list]
    D -.->|양방향| D1[list, set, map]
    E -.->|임의 접근| E1[vector, deque, array]
    F -.->|연속 메모리| F1[vector, array, string]
```### Iterator function comparison table
| iterator type | Read | writing | Forward | Reverse | random access | Example container |
|-------------|------|------|------|------|-----------|---------------|
| **Input** | ✅ | ❌ | ✅ | ❌ | ❌ | `istream_iterator` |
| **Output** | ❌ | ✅ | ✅ | ❌ | ❌ | `ostream_iterator` |
| **Forward** | ✅ | ✅ | ✅ | ❌ | ❌ | `forward_list` |
| **Bidirectional** | ✅ | ✅ | ✅ | ✅ | ❌ | `list`, `set`, `map` |
| **Random Access** | ✅ | ✅ | ✅ | ✅ | ✅ | `vector`, `deque` |
### Input Iterator
아래 코드는 cpp를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.
```cpp
// 읽기 전용, 한 번만 순회
istream_iterator<int> in(cin);
istream_iterator<int> eof;
vector<int> v(in, eof);  // 입력 읽기

Output Iterator

아래 코드는 cpp를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

// 쓰기 전용
ostream_iterator<int> out(cout, " ");
vector<int> v = {1, 2, 3};
copy(v.begin(), v.end(), out);  // 1 2 3

Forward Iterator

아래 코드는 cpp를 사용한 구현 예제입니다. 반복문으로 데이터를 처리합니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

// 읽기/쓰기, 여러 번 순회
forward_list<int> fl = {1, 2, 3};
for (auto it = fl.begin(); it != fl.end(); ++it) {
    *it *= 2;
}

Bidirectional Iterator

아래 코드는 cpp를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

// 양방향 이동
list<int> l = {1, 2, 3, 4, 5};
auto it = l.end();
--it;  // 마지막 원소
cout << *it << endl;  // 5

Random Access Iterator

아래 코드는 cpp를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.

// 임의 접근
vector<int> v = {1, 2, 3, 4, 5};
auto it = v.begin();
it += 3;  // 3칸 이동
cout << *it << endl;  // 4
cout << v[2] << endl;  // 3
```## Practical example
### Example 1: Custom iterator
다음은 cpp를 활용한 상세한 구현 코드입니다. 클래스를 정의하여 데이터와 기능을 캡슐화하며, 반복문으로 데이터를 처리합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
```cpp
class Range {
private:
    int current;
    int end;
    
public:
    class Iterator {
    private:
        int value;
        
    public:
        using iterator_category = forward_iterator_tag;
        using value_type = int;
        using difference_type = ptrdiff_t;
        using pointer = int*;
        using reference = int&;
        
        Iterator(int v) : value(v) {}
        
        int operator*() const { return value; }
        
        Iterator& operator++() {
            ++value;
            return *this;
        }
        
        bool operator!=(const Iterator& other) const {
            return value != other.value;
        }
    };
    
    Range(int start, int end) : current(start), end(end) {}
    
    Iterator begin() { return Iterator(current); }
    Iterator end() { return Iterator(this->end); }
};
int main() {
    for (int x : Range(0, 10)) {
        cout << x << " ";  // 0 1 2 ....9
    }
}
```### Example 2: Filter iterator
다음은 cpp를 활용한 상세한 구현 코드입니다. 클래스를 정의하여 데이터와 기능을 캡슐화하며, 반복문으로 데이터를 처리합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
```cpp
template<typename Iter, typename Pred>
class FilterIterator {
private:
    Iter current;
    Iter end;
    Pred predicate;
    
    void advance() {
        while (current != end && !predicate(*current)) {
            ++current;
        }
    }
    
public:
    FilterIterator(Iter begin, Iter end, Pred pred)
        : current(begin), end(end), predicate(pred) {
        advance();
    }
    
    auto operator*() const { return *current; }
    
    FilterIterator& operator++() {
        ++current;
        advance();
        return *this;
    }
    
    bool operator!=(const FilterIterator& other) const {
        return current != other.current;
    }
};
int main() {
    vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    
    auto isEven =  { return x % 2 == 0; };
    
    FilterIterator begin(v.begin(), v.end(), isEven);
    FilterIterator end(v.end(), v.end(), isEven);
    
    for (auto it = begin; it != end; ++it) {
        cout << *it << " ";  // 2 4 6 8 10
    }
}
```### Example 3: Conversion Iterator
다음은 cpp를 활용한 상세한 구현 코드입니다. 클래스를 정의하여 데이터와 기능을 캡슐화하며, 반복문으로 데이터를 처리합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
```cpp
template<typename Iter, typename Func>
class TransformIterator {
private:
    Iter current;
    Func transform;
    
public:
    TransformIterator(Iter it, Func f) : current(it), transform(f) {}
    
    auto operator*() const {
        return transform(*current);
    }
    
    TransformIterator& operator++() {
        ++current;
        return *this;
    }
    
    bool operator!=(const TransformIterator& other) const {
        return current != other.current;
    }
};
int main() {
    vector<int> v = {1, 2, 3, 4, 5};
    
    auto square =  { return x * x; };
    
    TransformIterator begin(v.begin(), square);
    TransformIterator end(v.end(), square);
    
    for (auto it = begin; it != end; ++it) {
        cout << *it << " ";  // 1 4 9 16 25
    }
}
```## Iterator operations
### Iterator operation function comparison
| function | Time Complexity | Support iterators | Description |
|------|-------------|-------------|------|
| **advance(it, n)** | O(1) ~ O(N) | all iterators | Move n spaces (Modify position) |
| **distance(first, last)** | O(1) ~ O(N) | Input or more | Distance between two iterators |
| **next(it, n=1)** | O(1) ~ O(N) | Forward or more | Return iterator n spaces ahead |
| **prev(it, n=1)** | O(1) ~ O(N) | Bidirectional ideal | return iterator after n spaces |
| **iter_swap(it1, it2)** | O(1) | Forward or more | Swap two iterator values ​​|```cpp
// 실행 예제
vector<int> v = {1, 2, 3, 4, 5};
auto it = v.begin();
// 전진
advance(it, 3);  // 3칸 이동
cout << *it << endl;  // 4
// 거리
auto dist = distance(v.begin(), v.end());
cout << dist << endl;  // 5
// 다음/이전
auto next_it = next(it);
auto prev_it = prev(it);

advance vs next difference:```mermaid graph LR A[it = v.begin] —> B{Which?}

B -->|advance it, 3| C[Modify it]
C --> D[it = begin+3]

B -->|next it, 3| E[Return new]
E --> F[it = begin]
E --> G[return = begin+3]

### Problem 1: Invalidated Iterators
다음은 cpp를 활용한 상세한 구현 코드입니다. 반복문으로 데이터를 처리합니다, 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
```cpp
// ❌ 반복자 무효화
vector<int> v = {1, 2, 3, 4, 5};
for (auto it = v.begin(); it != v.end(); ++it) {
    if (*it == 3) {
        v.erase(it);  // it 무효화!
        // ++it;  // 위험!
    }
}
// ✅ erase 반환값 사용
for (auto it = v.begin(); it != v.end();) {
    if (*it == 3) {
        it = v.erase(it);  // 다음 반복자 반환
    } else {
        ++it;
    }
}
```### Problem 2: end() dereference
아래 코드는 cpp를 사용한 구현 예제입니다. 조건문으로 분기 처리를 수행합니다. 코드를 직접 실행해보면서 동작을 확인해보세요.
```cpp
// ❌ end() 역참조
vector<int> v = {1, 2, 3};
auto it = v.end();
// cout << *it << endl;  // UB
// ✅ end() 체크
if (it != v.end()) {
    cout << *it << endl;
}
```### Problem 3: Iterator type mismatch
아래 코드는 cpp를 사용한 구현 예제입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
```cpp
// ❌ 타입 불일치
vector<int> v;
list<int> l;
// auto it = v.begin();
// it = l.begin();  // 에러
// ✅ 올바른 타입
auto vit = v.begin();
auto lit = l.begin();

iterator_traits

아래 코드는 cpp를 사용한 구현 예제입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

template<typename Iter>
void printIteratorInfo() {
    using traits = iterator_traits<Iter>;
    
    cout << "value_type: " << typeid(typename traits::value_type).name() << endl;
    cout << "difference_type: " << typeid(typename traits::difference_type).name() << endl;
    cout << "iterator_category: " << typeid(typename traits::iterator_category).name() << endl;
}
int main() {
    printIteratorInfo<vector<int>::iterator>();
}
```## FAQ
### Q1: When do you use iterators?
**A**: 
- Container traversal
- STL algorithm
- Specify scope
### Q2: Pointer vs Iterator?
**A**: Iterators are more abstract and safer.
### Q3: What about iterator invalidation?
**A**: 
- vector: When inserting/deleting
- list: only deleted elements
- map: only deleted elements
### Q4: What about custom iterators?
**A**: Requires implementation of 5 typedefs and operators.
### Q5: What is the iterator performance?
**A**: Inlined, similar to a pointer.
### Q6: What are the iterator learning resources?
**A**:
- "Effective STL" (Scott Meyers)
- cppreference.com
- "The C++ Standard Library"
**Related posts**: [Range-based for](/blog/cpp-range-based-for/), [Vector complete guide](/blog/cpp-stl-vector-complete/), [size_t·ptrdiff_t](/blog/cpp-size-t-ptrdiff-t/), [Composite pattern](/blog/cpp-composite-pattern/).
---
## Good article to read together (internal link)

Here's another article related to this topic.
- [C++ range-based for | "Range-based for" guide](/blog/cpp-range-based-for/)
- [C++ STL vector | "Easier than arrays" Complete vector summary [Practical example]](/blog/cpp-stl-vector-complete/)
- [C++ size_t & ptrdiff_t | “Size Type” Guide](/blog/cpp-size-t-ptrdiff-t/)
- [Complete Guide to C++ Composite Pattern | Treating the tree structure as the same interface](/blog/cpp-composite-pattern/)
## Practical tips

These are tips that can be applied right away in practice.
### Debugging tips
- If you run into a problem, check the compiler warnings first.
- Reproduce the problem with a simple test case
### Performance Tips
- Don't optimize without profiling
- Set measurable indicators first
### Code review tips
- Check in advance for areas that are frequently pointed out in code reviews.
- Follow your team's coding conventions
---
## Practical checklist

This is what you need to check when applying this concept in practice.
### Before writing code
- [ ] Is this technique the best way to solve the current problem?
- [ ] Can team members understand and maintain this code?
- [ ] Does it meet the performance requirements?
### Writing code
- [ ] Have you resolved all compiler warnings?
- [ ] Have you considered edge cases?
- [ ] Is error handling appropriate?
### When reviewing code
- [ ] Is the intent of the code clear?
- [ ] Are there enough test cases?
- [ ] Is it documented?
Use this checklist to reduce mistakes and improve code quality.
---
## Keywords covered in this article (related search terms)

This article will be helpful if you search for **C++**, **iterator**, **iterator**, **STL**, **range**, etc.
---
## Related articles

- [C++ iterator invalidation error | ](/blog/cpp-error-05-iterator-invalidation/)
- [A complete guide to C++ iterator basics | iterator category·begin/end·reverse iterator·practical pattern](/blog/cpp-series-17-1-iterator-basics/)
- [C++ Custom Iterator Complete Guide | Forward·Bidirectional](/blog/cpp-series-17-2-custom-iterator/)
- [C++20 Ranges | Escaping the begin/end loop and writing the ranges algorithm](/blog/cpp-series-25-1-ranges-basics/)
- [C++ Tag Dispatch Complete Guide | Compile-time function selection and STL optimization](/blog/cpp-tag-dispatch/)