Реализация своих итераторов в C++

class SimpleInputIterator {
public:
    using value_type = SomeType;
    using difference_type = std::ptrdiff_t;
    using pointer = SomeType*;
    using reference = SomeType&;
    using iterator_category = std::input_iterator_tag;
    
    reference operator*() const;
    SimpleInputIterator& operator++();
    // и другие необходимые операции
};

template <typename T>
class RandomAccessIterator {
public:
    // определения типов как выше
    using iterator_category = std::random_access_iterator_tag;
    
    // Базовые операции
    reference operator*() const;
    RandomAccessIterator& operator++();
    
    // Операции произвольного доступа
    RandomAccessIterator operator+(difference_type n) const;
    difference_type operator-(const RandomAccessIterator& other) const;
    reference operator[](difference_type n) const;
    // и прочие операции
};

template <typename Iterator>
void sort_or_not(Iterator first, Iterator last) {
    if constexpr (std::is_same_v<
        typename std::iterator_traits<Iterator>::iterator_category,
        std::random_access_iterator_tag
    >) {
        // Используем быструю сортировку
        std::sort(first, last);
    } else {
        // Используем сортировку, не требущую произвольного доступа
        std::list<typename std::iterator_traits<Iterator>::value_type>
            temp(first, last);
        temp.sort();
        std::copy(temp.begin(), temp.end(), first);
    }
}

template <typename T>
concept Incrementable = requires(T t) {
    { ++t } -> std::same_as<T&>;
    { t++ } -> std::same_as<T>;
};
 
template <typename T>
concept InputIterator = Incrementable<T> && requires(T t) {
    { *t } -> std::convertible_to<typename std::iter_value_t<T>>;
    // Другие требования...
};

// Специализация iterator_traits для пользовательского типа
namespace std {
template <>
struct iterator_traits<MyWeirdIterator> {
    using difference_type = std::ptrdiff_t;
    using value_type = int;
    using pointer = int*;
    using reference = int&;
    using iterator_category = std::forward_iterator_tag;
};
}

std::vector<int> nums = {1, 2, 3, 4, 5};
// По-старому
std::sort(nums.begin(), nums.end());
// С использованием ranges
std::ranges::sort(nums);

class CustomInputIterator {
public:
    // Определения типов через using
    using value_type = T;
    using difference_type = std::ptrdiff_t;
    using pointer = T*;
    using reference = T&;
    using iterator_category = std::input_iterator_tag;
    
    // Конструктор
    CustomInputIterator(pointer ptr) : m_ptr(ptr) {}
    
    // Операции разыменования
    reference operator*() const { return *m_ptr; }
    pointer operator->() { return m_ptr; }
    
    // Инкремент (префиксный и постфиксный)
    CustomInputIterator& operator++() {
        m_ptr++;
        return *this;
    }
    
    CustomInputIterator operator++(int) {
        CustomInputIterator tmp = *this;
        ++(*this);
        return tmp;
    }
    
    // Операторы сравнения
    friend bool operator==(const CustomInputIterator& a, const CustomInputIterator& b) {
        return a.m_ptr == b.m_ptr;
    }
    
    friend bool operator!=(const CustomInputIterator& a, const CustomInputIterator& b) {
        return !(a == b);
    }
    
private:
    pointer m_ptr;
};

template <typename T>
class RandomIterator {
public:
    // ... другие определения ...
    
    // Операторы сравнения
    friend bool operator==(const RandomIterator& a, const RandomIterator& b) {
        return a.m_ptr == b.m_ptr;
    }
    
    friend bool operator!=(const RandomIterator& a, const RandomIterator& b) {
        return !(a == b);
    }
    
    friend bool operator<(const RandomIterator& a, const RandomIterator& b) {
        return a.m_ptr < b.m_ptr;
    }
    
    friend bool operator<=(const RandomIterator& a, const RandomIterator& b) {
        return a.m_ptr <= b.m_ptr;
    }
    
    friend bool operator>(const RandomIterator& a, const RandomIterator& b) {
        return a.m_ptr > b.m_ptr;
    }
    
    friend bool operator>=(const RandomIterator& a, const RandomIterator& b) {
        return a.m_ptr >= b.m_ptr;
    }
};

// C++20 и новее
friend auto operator<=>(const RandomIterator& a, const RandomIterator& b) = default;

template <typename T>
class CustomContainer {
public:
    using iterator = CustomIterator<T>;
    
    iterator begin() { return iterator(data); }
    iterator end() { return iterator(data + size); }
    
    // ... остальные члены класса ...
private:
    T* data;
    size_t size;
};

namespace std {
    template <>
    auto begin(const CustomContainer& c) {
        return c.begin();
    }
    
    template <>
    auto end(const CustomContainer& c) {
        return c.end();
    }
}

template <typename Iterator, typename UnaryOperation>
class TransformIterator {
public:
    // Наследуем категорию от базового итератора
    using iterator_category = typename std::iterator_traits<Iterator>::iterator_category;
    // Тип значения определяется результатом операции
    using value_type = typename std::decay<
        decltype(std::declval<UnaryOperation>()(*std::declval<Iterator>()))
    >::type;
    using difference_type = typename std::iterator_traits<Iterator>::difference_type;
    using pointer = value_type*;
    using reference = value_type&;
    
    TransformIterator(Iterator it, UnaryOperation op) : m_it(it), m_op(op) {}
    
    auto operator*() const { return m_op(*m_it); }
    
    TransformIterator& operator++() {
        ++m_it;
        return *this;
    }
    
    // ... прочие операторы ...
    
private:
    Iterator m_it;
    UnaryOperation m_op;
};

template <typename Iterator, typename Projector>
class ProjectionIterator {
public:
 using base_value_type = typename std::iterator_traits<Iterator>::value_type;
 using value_type = std::invoke_result_t<Projector, base_value_type&>;
 // ... остальные определения типов ...
 
 ProjectionIterator(Iterator it, Projector proj) : m_it(it), m_proj(proj) {}
 
 auto operator*() const { return m_proj(*m_it); }
 
 // ... остальные операторы ...
 
private:
 Iterator m_it;
 Projector m_proj;
};
 
// Вспомогательная функция для создания итератора проекции
template <typename Iterator, typename Projector>
auto make_projection_iterator(Iterator it, Projector proj) {
 return ProjectionIterator<Iterator, Projector>(it, proj);
}

struct Person {
 std::string name;
 int age;
};
 
std::vector<Person> people = { /* ... */ };
 
// Сортировка по возрасту без изменения оригинального контейнера
auto begin = make_projection_iterator(people.begin(), [](const Person& p) { return p.age; });
auto end = make_projection_iterator(people.end(), [](const Person& p) { return p.age; });
std::sort(begin, end);

template <typename Iterator, typename Predicate>
class FilterIterator {
public:
 using iterator_category = std::forward_iterator_tag; // Не может быть произвольного доступа
 using value_type = typename std::iterator_traits<Iterator>::value_type;
 using difference_type = typename std::iterator_traits<Iterator>::difference_type;
 using pointer = typename std::iterator_traits<Iterator>::pointer;
 using reference = typename std::iterator_traits<Iterator>::reference;
 
 FilterIterator(Iterator begin, Iterator end, Predicate pred)
     : m_current(begin), m_end(end), m_pred(pred) {
     // Найти первый подходящий элемент
     while (m_current != m_end && !m_pred(*m_current)) {
         ++m_current;
     }
 }
 
 reference operator*() const { return *m_current; }
 
 FilterIterator& operator++() {
     // Найти следующий подходящий элемент
     do {
         ++m_current;
     } while (m_current != m_end && !m_pred(*m_current));
     return *this;
 }
 
 // ... остальные операторы ...
 
private:
 Iterator m_current;
 Iterator m_end;
 Predicate m_pred;
};

template <typename T, bool IsConst>
class CustomContainerIterator {
public:
 using value_type = T;
 using reference = typename std::conditional<IsConst, const T&, T&>::type;
 using pointer = typename std::conditional<IsConst, const T*, T*>::type;
 // ... остальные определения типов ...
 
 reference operator*() const { return *m_ptr; }
 // ... остальные операторы ...
 
private:
 pointer m_ptr;
};
 
template <typename T>
class CustomContainer {
public:
 using iterator = CustomContainerIterator<T, false>;
 using const_iterator = CustomContainerIterator<T, true>;
 
 iterator begin() { return iterator(data); }
 const_iterator begin() const { return const_iterator(data); }
 const_iterator cbegin() const { return const_iterator(data); }
 
 // ... аналогично для end() ...
 
private:
 T* data;
 size_t size;
};

template <typename T>
class BinaryTreeInorderIterator {
public:
 using value_type = T;
 using reference = T&;
 using pointer = T*;
 using iterator_category = std::forward_iterator_tag;
 using difference_type = std::ptrdiff_t;
 
 BinaryTreeInorderIterator(TreeNode<T>* root) {
     if (root) {
         // Спуститься до самого левого листа
         while (root) {
             m_stack.push(root);
             root = root->left;
         }
     }
 }
 
 reference operator*() const { return m_stack.top()->value; }
 
 BinaryTreeInorderIterator& operator++() {
     TreeNode<T>* node = m_stack.top();
     m_stack.pop();
     
     // Если есть правый потомок, спуститься до самого левого листа в правом поддереве
     if (node->right) {
         node = node->right;
         while (node) {
             m_stack.push(node);
             node = node->left;
         }
     }
     
     return *this;
 }
 
 // ... остальные операторы ...
 
private:
 std::stack<TreeNode<T>*> m_stack;
};

template <typename Derived, typename T>
class IteratorBase {
public:
 using value_type = T;
 // ... остальные определения типов ...
 
 Derived& operator++() {
     static_cast<Derived*>(this)->increment();
     return *static_cast<Derived*>(this);
 }
 
 // ... общие операторы для всех итераторов ...
 
protected:
 // Должен быть переопределен в производном классе
 void increment() = delete;
};
 
template <typename T>
class CustomIterator : public IteratorBase<CustomIterator<T>, T> {
public:
 // ... конструкторы ...
 
 void increment() {
     // Реализация инкремента
 }
 
 // ... специфичные для данного итератора операторы ...
};

template <typename T, size_t Capacity>
class CircularBuffer {
public:
    CircularBuffer() : head(0), tail(0), size(0) {}
    
    void push_back(const T& value) {
        if (size == Capacity) {
            // Перезаписываем самый старый элемент
            data[head] = value;
            head = (head + 1) % Capacity;
            tail = (tail + 1) % Capacity;
        } else {
            data[tail] = value;
            tail = (tail + 1) % Capacity;
            size++;
        }
    }
    
    T& front() { return data[head]; }
    
    void pop_front() {
        if (size > 0) {
            head = (head + 1) % Capacity;
            size--;
        }
    }
    
    // ... другие методы кольцевого буфера ...
    
    // Теперь добавим итератор
    class iterator {
    public:
        using value_type = T;
        using difference_type = std::ptrdiff_t;
        using pointer = T*;
        using reference = T&;
        using iterator_category = std::forward_iterator_tag;
        
        iterator(CircularBuffer* buffer, size_t pos, size_t count)
            : buffer(buffer), pos(pos), count(count) {}
        
        reference operator*() const {
            return buffer->data[pos];
        }
        
        pointer operator->() const {
            return &buffer->data[pos];
        }
        
        iterator& operator++() {
            pos = (pos + 1) % Capacity;
            count++;
            return *this;
        }
        
        iterator operator++(int) {
            iterator tmp = *this;
            ++(*this);
            return tmp;
        }
        
        friend bool operator==(const iterator& a, const iterator& b) {
            return a.buffer == b.buffer && a.count == b.count;
        }
        
        friend bool operator!=(const iterator& a, const iterator& b) {
            return !(a == b);
        }
        
    private:
        CircularBuffer* buffer;
        size_t pos;  // Текущая позиция в буфере
        size_t count; // Количество пройденных элементов
    };
    
    iterator begin() {
        return iterator(this, head, 0);
    }
    
    iterator end() {
        return iterator(this, head, size);
    }
    
private:
    T data[Capacity];
    size_t head; // Индекс первого элемента
    size_t tail; // Индекс следующего свободного места
    size_t size; // Текущий размер
};

CircularBuffer<int, 5> buffer;
buffer.push_back(1);
buffer.push_back(2);
buffer.push_back(3);
 
for (auto it = buffer.begin(); it != buffer.end(); ++it) {
    std::cout << *it << " ";
}
// Выведет: 1 2 3
 
for (auto& val : buffer) {  // Работает благодаря итераторам!
    std::cout << val << " ";
}
// Выведет: 1 2 3

template <typename T>
class DoublyLinkedList {
private:
    struct Node {
        T value;
        Node* prev;
        Node* next;
        
        Node(const T& val) : value(val), prev(nullptr), next(nullptr) {}
    };
    
    Node* head;
    Node* tail;
    size_t size;
    
public:
    DoublyLinkedList() : head(nullptr), tail(nullptr), size(0) {}
    
    ~DoublyLinkedList() {
        while (head) {
            Node* temp = head;
            head = head->next;
            delete temp;
        }
    }
    
    void push_back(const T& value) {
        Node* newNode = new Node(value);
        if (!head) {
            head = tail = newNode;
        } else {
            newNode->prev = tail;
            tail->next = newNode;
            tail = newNode;
        }
        size++;
    }
    
    // ... другие методы списка ...
    
    class iterator {
    public:
        using value_type = T;
        using difference_type = std::ptrdiff_t;
        using pointer = T*;
        using reference = T&;
        using iterator_category = std::bidirectional_iterator_tag; // Обратите внимание!
        
        iterator(Node* node) : current(node) {}
        
        reference operator*() const {
            return current->value;
        }
        
        pointer operator->() const {
            return &current->value;
        }
        
        iterator& operator++() {
            if (current) current = current->next;
            return *this;
        }
        
        iterator operator++(int) {
            iterator tmp = *this;
            ++(*this);
            return tmp;
        }
        
        // Операторы для двунаправленного итератора
        iterator& operator--() {
            if (current) current = current->prev;
            return *this;
        }
        
        iterator operator--(int) {
            iterator tmp = *this;
            --(*this);
            return tmp;
        }
        
        friend bool operator==(const iterator& a, const iterator& b) {
            return a.current == b.current;
        }
        
        friend bool operator!=(const iterator& a, const iterator& b) {
            return !(a == b);
        }
        
    private:
        Node* current;
    };
    
    iterator begin() {
        return iterator(head);
    }
    
    iterator end() {
        return iterator(nullptr);
    }
};

template <typename T>
class DynamicArray {
private:
    T* data;
    size_t capacity;
    size_t size;
    
public:
    DynamicArray() : data(nullptr), capacity(0), size(0) {}
    
    ~DynamicArray() {
        delete[] data;
    }
    
    void push_back(const T& value) {
        if (size == capacity) {
            // Увеличиваем ёмкость
            capacity = capacity ? capacity * 2 : 1;
            T* newData = new T[capacity];
            for (size_t i = 0; i < size; ++i) {
                newData[i] = data[i];
            }
            delete[] data;
            data = newData;
        }
        data[size++] = value;
    }
    
    // ... другие методы ...
    
    class iterator {
    public:
        using value_type = T;
        using difference_type = std::ptrdiff_t;
        using pointer = T*;
        using reference = T&;
        using iterator_category = std::random_access_iterator_tag; // Обратите внимание!
        
        iterator(pointer ptr) : ptr(ptr) {}
        
        reference operator*() const {
            return *ptr;
        }
        
        pointer operator->() const {
            return ptr;
        }
        
        // Базовые операторы
        iterator& operator++() {
            ++ptr;
            return *this;
        }
        
        iterator operator++(int) {
            iterator tmp = *this;
            ++(*this);
            return tmp;
        }
        
        iterator& operator--() {
            --ptr;
            return *this;
        }
        
        iterator operator--(int) {
            iterator tmp = *this;
            --(*this);
            return tmp;
        }
        
        // Операторы произвольного доступа
        iterator& operator+=(difference_type n) {
            ptr += n;
            return *this;
        }
        
        iterator operator+(difference_type n) const {
            return iterator(ptr + n);
        }
        
        friend iterator operator+(difference_type n, const iterator& it) {
            return it + n;
        }
        
        iterator& operator-=(difference_type n) {
            ptr -= n;
            return *this;
        }
        
        iterator operator-(difference_type n) const {
            return iterator(ptr - n);
        }
        
        difference_type operator-(const iterator& other) const {
            return ptr - other.ptr;
        }
        
        reference operator[](difference_type n) const {
            return *(ptr + n);
        }
        
        // Операторы сравнения
        friend bool operator==(const iterator& a, const iterator& b) {
            return a.ptr == b.ptr;
        }
        
        friend bool operator!=(const iterator& a, const iterator& b) {
            return !(a == b);
        }
        
        friend bool operator<(const iterator& a, const iterator& b) {
            return a.ptr < b.ptr;
        }
        
        friend bool operator<=(const iterator& a, const iterator& b) {
            return a.ptr <= b.ptr;
        }
        
        friend bool operator>(const iterator& a, const iterator& b) {
            return a.ptr > b.ptr;
        }
        
        friend bool operator>=(const iterator& a, const iterator& b) {
            return a.ptr >= b.ptr;
        }
        
    private:
        pointer ptr;
    };
    
    iterator begin() {
        return iterator(data);
    }
    
    iterator end() {
        return iterator(data + size);
    }
};

template <typename T>
class SparseMatrix {
private:
    std::map<std::pair<size_t, size_t>, T> nonZeroElements;
    size_t rows, cols;
 
public:
    SparseMatrix(size_t r, size_t c) : rows(r), cols(c) {}
 
    T& operator()(size_t row, size_t col) {
        if (row >= rows || col >= cols) throw std::out_of_range("Matrix indices out of range");
        return nonZeroElements[{row, col}];
    }
 
    // Итератор только по ненулевым элементам
    class SparseIterator {
    public:
        using value_type = std::pair<std::pair<size_t, size_t>, T>;
        using iterator_category = std::forward_iterator_tag;
        using difference_type = std::ptrdiff_t;
        using pointer = value_type*;
        using reference = value_type&;
 
        SparseIterator(typename std::map<std::pair<size_t, size_t>, T>::iterator it)
            : current(it) {}
 
        auto operator*() const {
            return std::make_pair(current->first, current->second);
        }
 
        SparseIterator& operator++() {
            ++current;
            return *this;
        }
 
        SparseIterator operator++(int) {
            SparseIterator tmp = *this;
            ++(*this);
            return tmp;
        }
 
        friend bool operator==(const SparseIterator& a, const SparseIterator& b) {
            return a.current == b.current;
        }
 
        friend bool operator!=(const SparseIterator& a, const SparseIterator& b) {
            return !(a == b);
        }
 
    private:
        typename std::map<std::pair<size_t, size_t>, T>::iterator current;
    };
 
    SparseIterator begin() { return SparseIterator(nonZeroElements.begin()); }
    SparseIterator end() { return SparseIterator(nonZeroElements.end()); }
};

class FullMatrixIterator {
public:
    using iterator_category = std::forward_iterator_tag;
    // ... другие типы ...
 
    FullMatrixIterator(SparseMatrix* matrix, size_t row = 0, size_t col = 0)
        : matrix(matrix), currentRow(row), currentCol(col) {
        skipToNonZeroOrEnd();
    }
 
    auto operator*() const {
        auto pos = std::make_pair(currentRow, currentCol);
        auto it = matrix->nonZeroElements.find(pos);
        if (it != matrix->nonZeroElements.end()) {
            return std::make_pair(pos, it->second);
        }
        return std::make_pair(pos, T()); // Возвращаем нулевой элемент
    }
 
    FullMatrixIterator& operator++() {
        ++currentCol;
        if (currentCol >= matrix->cols) {
            currentCol = 0;
            ++currentRow;
        }
        return *this;
    }
 
    // ... другие операторы ...
 
private:
    SparseMatrix* matrix;
    size_t currentRow, currentCol;
 
    void skipToNonZeroOrEnd() {
        while (currentRow < matrix->rows && 
               matrix->nonZeroElements.find({currentRow, currentCol}) == matrix->nonZeroElements.end()) {
            ++currentCol;
            if (currentCol >= matrix->cols) {
                currentCol = 0;
                ++currentRow;
            }
        }
    }
};

template<typename Container, bool IsConst>
class GenericIterator {
private:
    using ContainerType = std::conditional_t<IsConst, const Container, Container>;
    using ValueType = std::conditional_t<IsConst, const typename Container::value_type, 
                                         typename Container::value_type>;
public:
    using value_type = typename Container::value_type;
    using reference = std::conditional_t<IsConst, const value_type&, value_type&>;
    using pointer = std::conditional_t<IsConst, const value_type*, value_type*>;
    using iterator_category = std::bidirectional_iterator_tag;
    using difference_type = std::ptrdiff_t;
 
    // ... реализация операторов ...
};
 
template <typename T>
class MyContainer {
public:
    using value_type = T;
    using iterator = GenericIterator<MyContainer, false>;
    using const_iterator = GenericIterator<MyContainer, true>;
 
    iterator begin() { return iterator(this, /* начальное состояние */); }
    const_iterator begin() const { return const_iterator(this, /* начальное состояние */); }
    const_iterator cbegin() const { return const_iterator(this, /* начальное состояние */); }
 
    // ... аналогично для end() ...
};

template <typename Iterator>
void validate_random_access_iterator() {
    static_assert(std::is_same_v<
        typename std::iterator_traits<Iterator>::iterator_category,
        std::random_access_iterator_tag
    >, "Not a random access iterator");
 
    // Проверяем наличие основных операторов
    Iterator it1, it2;
    typename std::iterator_traits<Iterator>::difference_type n = 0;
    typename std::iterator_traits<Iterator>::reference r = *it1;
    it1 + n;
    n + it1;
    it1 - n;
    it1 - it2;
    it1[n];
    it1 < it2;
}

template <typename Node>
class CycleSafeIterator {
private:
    Node* current;
    std::unordered_set<Node*> visited;
 
public:
    // ... конструктор и другие операторы ...
 
    CycleSafeIterator& operator++() {
        if (current && !current->children.empty()) {
            for (auto* child : current->children) {
                if (visited.find(child) == visited.end()) {
                    visited.insert(child);
                    current = child;
                    return *this;
                }
            }
        }
        // Если все дети посещены или их нет, идем к следующему узлу...
        current = nullptr; // Или другая логика перехода
        return *this;
    }
};

template <typename T>
class VersionedContainer {
private:
    std::vector<T> data;
    size_t version = 0;
 
public:
    void push_back(const T& value) {
        data.push_back(value);
        ++version;
    }
 
    class iterator {
    private:
        VersionedContainer* container;
        size_t position;
        size_t iteratorVersion;
 
    public:
        iterator(VersionedContainer* c, size_t pos)
            : container(c), position(pos), iteratorVersion(c->version) {}
 
        iterator& operator++() {
            if (iteratorVersion != container->version)
                throw std::runtime_error("Container modified during iteration");
            ++position;
            return *this;
        }
 
        // ... другие операторы ...
    };
};

template <typename Derived>
class IteratorBase {
public:
    Derived& operator++() {
        return static_cast<Derived&>(*this).increment();
    }
 
    Derived operator++(int) {
        Derived tmp(static_cast<Derived&>(*this));
        static_cast<Derived&>(*this).increment();
        return tmp;
    }
 
    // ... другие общие операторы ...
};
 
template <typename T>
class VectorIterator : public IteratorBase<VectorIterator<T>> {
private:
    T* ptr;
 
public:
    VectorIterator(T* p) : ptr(p) {}
 
    T& operator*() const { return *ptr; }
    
    // Этот метод вызывается базовым классом
    VectorIterator& increment() {
        ++ptr;
        return *this;
    }
 
    // ... специфичные для вектора операторы ...
};

// Антипаттерн: тяжеловесный итератор
template <typename T>
class HeavyIterator {
private:
    std::vector<T>* container;  // Указатель на контейнер
    size_t position;
    std::map<int, std::string> metadataCache;  // Избыточная информация
    std::vector<size_t> visitHistory;  // Зачем это здесь?
    
public:
    // ... интерфейс итератора ...
};

template <typename T>
class LightweightIterator {
private:
    T* ptr;  // Только необходимый минимум
    
public:
    // ... интерфейс итератора ...
};

class GraphIterator {
private:
    Node* current;
    std::unordered_set<Node*>* visited;  // Динамически созданный набор
    
public:
    GraphIterator() : visited(new std::unordered_set<Node*>) {}
    // Ой, забыли деструктор!
};

class GraphIterator {
private:
    Node* current;
    std::unique_ptr<std::unordered_set<Node*>> visited;  // Умный указатель
    
public:
    GraphIterator() : visited(std::make_unique<std::unordered_set<Node*>>()) {}
    // Теперь утечки не будет
};

// Неправильно
friend bool operator==(const Iterator& a, const Iterator& b) {
    return a.ptr == b.ptr;  // Сравниваем только указатели
}

friend bool operator==(const Iterator& a, const Iterator& b) {
    return a.container == b.container && a.ptr == b.ptr;
}

template <typename T>
class ThreadSafeIterator {
private:
    std::vector<T>* container;
    size_t position;
    std::mutex& mutex;  // Ссылка на мьютекс контейнера
    
public:
    ThreadSafeIterator(std::vector<T>* c, size_t pos, std::mutex& m)
        : container(c), position(pos), mutex(m) {}
        
    T& operator*() {
        std::lock_guard<std::mutex> lock(mutex);
        return (*container)[position];
    }
    
    // ... Другие операторы ...
};

template <typename T>
class SnapshotIterator {
private:
    std::vector<T> localCopy;  // Локальная копия данных
    size_t position;
    
public:
    SnapshotIterator(const std::vector<T>& original, size_t pos)
        : localCopy(original), position(pos) {}
        
    // Операции с localCopy теперь потокобезопасны
};

template <typename T>
class VersionedContainer {
private:
    std::vector<T> data;
    std::atomic<size_t> version{0};
    
public:
    void modify() {
        // Изменение данных
        ++version;  // Увеличиваем версию
    }
    
    class iterator {
    private:
        VersionedContainer* container;
        size_t myVersion;
        
    public:
        T& operator*() {
            if (myVersion != container->version)
                throw std::runtime_error("Iterator invalidated");
            // Доступ к данным
        }
    };
};

class InventorySystem {
private:
    struct Item {
        std::string sku;
        std::string name;
        double price;
        int stockQuantity;
        // ... другие поля ...
    };
    
    CustomIndexedTree<std::string, Item> inventory;  // Наша специальная структура данных
    
public:
    // ... бизнес-методы ...
    
    // А вот и наш итератор!
    class iterator {
        // ... реализация ...
    };
    
    iterator begin() { return iterator(inventory.root(), /* параметры обхода */); }
    iterator end() { return iterator(nullptr); }
};

InventorySystem warehouse;
// Находим товары с низким запасом
auto lowStock = std::find_if(warehouse.begin(), warehouse.end(), 
                             [](const auto& item) { return item.stockQuantity < 10; });
 
// Считаем общую стоимость инвентаря
double totalValue = std::accumulate(warehouse.begin(), warehouse.end(), 0.0,
                                  [](double sum, const auto& item) {
                                      return sum + item.price * item.stockQuantity;
                                  });

class LogFileIterator {
private:
    std::ifstream file;
    std::string currentLine;
    LogEntry currentEntry;
    long currentPosition;
    bool fileEnded;
    
    // Парсинг строки лога в структурированный объект
    LogEntry parseLine(const std::string& line) {
        // ... логика парсинга ...
    }
    
public:
    LogFileIterator(const std::string& filepath, long startPos = 0)
        : file(filepath), currentPosition(startPos), fileEnded(false) {
        if (!file) throw std::runtime_error("Cannot open log file");
        file.seekg(startPos);
        if (file.good()) {
            std::getline(file, currentLine);
            currentEntry = parseLine(currentLine);
            currentPosition = file.tellg();
        } else {
            fileEnded = true;
        }
    }
    
    LogEntry& operator*() { return currentEntry; }
    
    LogFileIterator& operator++() {
        if (file.good()) {
            std::getline(file, currentLine);
            if (file.good()) {
                currentEntry = parseLine(currentLine);
                currentPosition = file.tellg();
            } else {
                fileEnded = true;
            }
        }
        return *this;
    }
    
    bool operator==(const LogFileIterator& other) const {
        if (fileEnded && other.fileEnded) return true;
        return currentPosition == other.currentPosition;
    }
    
    bool operator!=(const LogFileIterator& other) const {
        return !(*this == other);
    }
};
 
class LogAnalyzer {
public:
    LogFileIterator begin() { return LogFileIterator(logFilePath); }
    LogFileIterator end() { return LogFileIterator(""); }  // Специальный "end" итератор
    
    // ... методы анализа ...
};

LogAnalyzer analyzer("/var/log/huge_app.log");
 
// Подсчёт ошибок определённого типа
int errorCount = std::count_if(analyzer.begin(), analyzer.end(), 
                              [](const LogEntry& entry) {
                                  return entry.level == "ERROR" && 
                                         entry.message.find("Connection timed out") != std::string::npos;
                              });

template <typename RowType>
class DatabaseIterator {
private:
    SQLHSTMT statement;
    RowType currentRow;
    bool hasData;
    
    void fetchNext() {
        SQLRETURN ret = SQLFetch(statement);
        if (ret == SQL_SUCCESS || ret == SQL_SUCCESS_WITH_INFO) {
            hasData = true;
            // Заполняем currentRow данными из строки результата
            bindColumns();
        } else {
            hasData = false;
        }
    }
    
    void bindColumns() {
        // ... привязка столбцов результатов к полям currentRow ...
    }
    
public:
    DatabaseIterator(SQLHSTMT stmt) : statement(stmt), hasData(false) {
        fetchNext();
    }
    
    RowType& operator*() { return currentRow; }
    
    DatabaseIterator& operator++() {
        fetchNext();
        return *this;
    }
    
    // ... прочие операторы ...
};

template <typename BaseIterator>
class PrefetchingIterator {
private:
    BaseIterator current;
    BaseIterator next;
    BaseIterator end;
    std::future<void> prefetchTask;
    
    using value_type = typename std::iterator_traits<BaseIterator>::value_type;
    std::optional<value_type> nextValue;
    
    void startPrefetch() {
        if (next != end) {
            prefetchTask = std::async(std::launch::async, [this]() {
                nextValue = *next;
                ++next;
            });
        } else {
            nextValue = std::nullopt;
        }
    }
    
public:
    PrefetchingIterator(BaseIterator begin, BaseIterator end)
        : current(begin), next(begin != end ? std::next(begin) : end), end(end) {
        startPrefetch();
    }
    
    value_type& operator*() { return *current; }
    
    PrefetchingIterator& operator++() {
        if (prefetchTask.valid()) {
            prefetchTask.wait();  // Дожидаемся завершения загрузки
            current = std::prev(next);
            *current = std::move(*nextValue);  // Перемещаем предзагруженное значение
            startPrefetch();  // Запускаем загрузку следующего
        } else {
            ++current;  // Обычный инкремент, если предзагрузка недоступна
        }
        return *this;
    }
    
    // ... прочие операторы ...
};

template <typename Source, typename Transformer>
class TransformingStreamIterator {
private:
    Source& source;
    Transformer transformer;
    bool sourceEnded;
    
    using input_type = typename Source::value_type;
    using output_type = decltype(transformer(std::declval<input_type>()));
    
    output_type currentValue;
    
public:
    TransformingStreamIterator(Source& src, Transformer trans)
        : source(src), transformer(trans), sourceEnded(false) {
        if (source.hasNext()) {
            currentValue = transformer(source.next());
        } else {
            sourceEnded = true;
        }
    }
    
    // ... операторы итератора ...
};

// Создаём источники данных
NetworkDataSource networkSource("api.example.com/stream");
FileDataSource fileSource("backup.dat");
MergedDataSource mergedSource(networkSource, fileSource);
 
// Создаём преобразования
auto jsonParser = [](const std::string& raw) { return parseJson(raw); };
auto dataFilter = [](const JsonObject& json) { 
    return json.hasKey("priority") && json["priority"].asInt() > 5; 
};
auto dataMapper = [](const JsonObject& json) { 
    return DataRecord{json["id"].asString(), json["value"].asDouble()}; 
};
 
// Связываем всё в pipeline
using FilterIterator = FilteringStreamIterator<MergedDataSource, decltype(dataFilter)>;
using FinalIterator = TransformingStreamIterator<FilterIterator, decltype(dataMapper)>;
 
FilterIterator filtered(mergedSource, dataFilter);
FinalIterator pipeline(filtered, dataMapper);
 
// Обрабатываем результаты
for (auto it = pipeline.begin(); it != pipeline.end(); ++it) {
    processData(*it);
}

class MetricCollector {
private:
    std::vector<std::unique_ptr<MetricSourceBase>> sources;
    
public:
    void addSource(std::unique_ptr<MetricSourceBase> source) {
        sources.push_back(std::move(source));
    }
    
    class iterator {
    private:
        std::vector<std::unique_ptr<MetricSourceBase>>& sources;
        size_t currentSource;
        std::unique_ptr<MetricIteratorBase> currentIterator;
        
        void moveToNextValidSource() {
            while (currentSource < sources.size() && 
                  (!currentIterator || currentIterator->isEnd())) {
                currentSource++;
                if (currentSource < sources.size()) {
                    currentIterator = sources[currentSource]->createIterator();
                }
            }
        }
        
    public:
        iterator(std::vector<std::unique_ptr<MetricSourceBase>>& srcs, bool isEnd = false)
            : sources(srcs), currentSource(0) {
            if (!isEnd && !sources.empty()) {
                currentIterator = sources[0]->createIterator();
                moveToNextValidSource();
            } else {
                currentSource = sources.size();
            }
        }
        
        Metric& operator*() { return currentIterator->get(); }
        
        iterator& operator++() {
            if (currentIterator) {
                currentIterator->next();
                moveToNextValidSource();
            }
            return *this;
        }
        
        // ... другие операторы ...
    };
    
    iterator begin() { return iterator(sources); }
    iterator end() { return iterator(sources, true); }
};

template <typename Generator>
class LazySequenceIterator {
private:
    Generator generator;
    size_t position;
    std::optional<typename std::invoke_result_t<Generator, size_t>> cachedValue;
    
public:
    using value_type = typename std::invoke_result_t<Generator, size_t>;
    
    LazySequenceIterator(Generator gen, size_t pos = 0) 
        : generator(gen), position(pos) {
        if (position != std::numeric_limits<size_t>::max()) {
            cachedValue = generator(position);
        }
    }
    
    value_type operator*() const { 
        if (!cachedValue) {
            throw std::runtime_error("Dereferencing end iterator");
        }
        return *cachedValue; 
    }
    
    LazySequenceIterator& operator++() {
        position++;
        if (position != std::numeric_limits<size_t>::max()) {
            cachedValue = generator(position);
        } else {
            cachedValue.reset();
        }
        return *this;
    }
    
    // ... другие операторы ...
};
 
// Использование:
auto primeGenerator = [](size_t n) -> int {
    // Тяжёлые вычисления для нахождения n-го простого числа
    // ...
    return nthPrime;
};
 
LazySequenceIterator<decltype(primeGenerator)> begin(primeGenerator);
LazySequenceIterator<decltype(primeGenerator)> end(primeGenerator, std::numeric_limits<size_t>::max());
 
// Найти первое простое число больше 1000
auto it = std::find_if(begin, end, [](int prime) { return prime > 1000; });
std::cout << "First prime > 1000: " << *it << std::endl;

class FibonacciIterator {
private:
    unsigned long long a, b;
    
public:
    FibonacciIterator(unsigned long long a = 0, unsigned long long b = 1) 
        : a(a), b(b) {}
        
    unsigned long long operator*() const { return a; }
    
    FibonacciIterator& operator++() {
        unsigned long long next = a + b;
        a = b;
        b = next;
        return *this;
    }
    
    // Для этого итератора нет "конца", поэтому сравнение не имеет смысла
    // или можно ограничить по максимальному значению
};

template <typename T, size_t Dimensions>
class ZCurveIterator {
private:
    std::array<size_t, Dimensions> dimensions;
    std::array<size_t, Dimensions> current;
    T* data;
    
    // Функция для конвертации многомерного индекса в Z-индекс
    size_t toZIndex(const std::array<size_t, Dimensions>& indices) {
        // Реализация Z-кривой...
    }
    
public:
    ZCurveIterator(T* data, const std::array<size_t, Dimensions>& dims)
        : data(data), dimensions(dims) {
        std::fill(current.begin(), current.end(), 0);
    }
    
    T& operator*() { return data[toZIndex(current)]; }
    
    ZCurveIterator& operator++() {
        // Инкремент по Z-кривой...
        return *this;
    }
    
    // ... другие операторы ...
};