Итераторы в C++: Продвинутые техники использования

template<typename Iterator>
void process_data(Iterator first, Iterator last) {
    while (first != last) {
        // Работа с *first
        ++first;
    }
}

template<typename Container>
void modern_process(Container& c) {
    for (auto& item : c) {  // Использование range-based for
        // Работа с item
    }
}

template<std::input_iterator It>  // Использование концепта
void safe_process(It first, It last) {
    while (first != last) {
        // Работа с *first
        ++first;
    }
}

class fibonacci_iterator {
    long long a = 0, b = 1;
public:
    using iterator_category = std::input_iterator_tag;
    using value_type = long long;
    using difference_type = std::ptrdiff_t;
    using pointer = const long long*;
    using reference = const long long&;
 
    fibonacci_iterator& operator++() { 
        long long temp = a;
        a = b;
        b += temp;
        return *this;
    }
    
    long long operator*() const { return a; }
    bool operator!=(const fibonacci_iterator&) const { return true; }
};

template<typename Iter, typename Func>
class transform_iterator {
    Iter it;
    Func func;
public:
    transform_iterator(Iter iter, Func f) 
        : it(iter), func(f) {}
    
    auto operator*() const { return func(*it); }
    transform_iterator& operator++() { ++it; return *this; }
    bool operator!=(const transform_iterator& other) const { 
        return it != other.it; 
    }
};

std::vector<int> numbers = {1, 2, 3, 4, 5};
auto result = numbers 
    | std::views::transform([](int x) { return x * x; })
    | std::views::filter([](int x) { return x > 10; });

generator<int> fibonacci() {
    int a = 0, b = 1;
    while (true) {
        co_yield a;
        int temp = a;
        a = b;
        b += temp;
    }
}

template<typename Iterator>
class bounds_checked_iterator {
    Iterator it;
    Iterator end;
public:
    bounds_checked_iterator(Iterator begin, Iterator end)
        : it(begin), end(end) {}
    
    auto operator*() {
        if (it == end) throw std::out_of_range("Iterator out of bounds");
        return *it;
    }
    // Остальные операторы...
};

std::istream_iterator<int> input(std::cin);
std::istream_iterator<int> end;
while (input != end) {
    int value = *input;
    ++input;
    // После продвижения итератора предыдущее значение может стать недоступным
}

std::vector<int> vec;
std::back_insert_iterator<std::vector<int>> inserter(vec);
*inserter = 1;  // Добавляет элемент в конец вектора
++inserter;     // Подготовка к следующей записи

template<typename ForwardIt>
bool all_equal(ForwardIt first, ForwardIt last) {
    if (first == last) return true;
    auto value = *first;
    while (++first != last) {
        if (*first != value) return false;
    }
    return true;
}

template<typename BidirIt>
void reverse_sequence(BidirIt first, BidirIt last) {
    while (first != last && first != --last) {
        std::swap(*first, *last);
        ++first;
    }
}

template<typename RandomIt>
void quick_sort_partition(RandomIt first, RandomIt last) {
    auto pivot = *(first + (last - first) / 2);
    auto i = first, j = last - 1;
    while (i <= j) {
        while (*i < pivot) ++i;
        while (*j > pivot) --j;
        if (i <= j) std::swap(*i++, *j--);
    }
}

template<std::bidirectional_iterator It>
void process_backwards(It first, It last) {
    while (last != first) {
        --last;
        // Работа с *last
    }
}

template<typename It>
    requires std::forward_iterator<It>
std::size_t distance_safe(It first, It last) {
    std::size_t count = 0;
    while (first != last) {
        ++first;
        ++count;
    }
    return count;
}

template<typename T>
class spiral_iterator {
    std::vector<std::vector<T>>& matrix;
    int x, y, layer;
    enum class Direction { Right, Down, Left, Up };
    Direction dir;
public:
    using iterator_category = std::forward_iterator_tag;
    using value_type = T;
    using difference_type = std::ptrdiff_t;
    using pointer = T*;
    using reference = T&;
 
    spiral_iterator(std::vector<std::vector<T>>& m, bool begin = true)
        : matrix(m), x(begin ? 0 : -1), y(0), layer(0), dir(Direction::Right) {}
 
    T& operator*() { return matrix[y][x]; }
    
    spiral_iterator& operator++() {
        switch(dir) {
            case Direction::Right:
                if (x + 1 < matrix[0].size() - layer) { ++x; }
                else { ++y; dir = Direction::Down; }
                break;
            // Остальные направления...
        }
        return *this;
    }
    
    bool operator!=(const spiral_iterator& other) const {
        return x != other.x || y != other.y;
    }
};

template<typename Container>
void safe_insert(Container& c, typename Container::iterator pos,
                 const typename Container::value_type& value) {
    auto offset = std::distance(c.begin(), pos);
    c.push_back(value);  // Может инвалидировать все итераторы
    pos = c.begin() + offset;  // Восстановление валидного итератора
}

template<typename Iterator>
bool is_sorted_and_unique(Iterator first, Iterator last) {
    if (first == last) return true;  // Пустая последовательность
    
    Iterator prev = first;
    while (++first != last) {
        if (*prev >= *first) return false;
        prev = first;
    }
    return true;
}

bool all_positive(std::ranges::range auto& r) {
    return std::ranges::all_of(r, [](const auto& x) { return x > 0; });
}

auto result = vec | std::views::filter([](int x) { return x % 2 == 0; })
                  | std::views::transform([](int x) { return x * 2; })
                  | std::views::take(5);

template<typename It>
requires std::bidirectional_iterator<It>
void reverse_blocks(It first, It last, std::size_t block_size) {
    while (std::distance(first, last) >= block_size) {
        auto block_end = std::next(first, block_size);
        std::reverse(first, block_end);
        first = block_end;
    }
    std::reverse(first, last);  // Последний неполный блок
}

std::vector<int> numbers = {1, 2, 3, 4, 5};
std::vector<int>::const_iterator it = numbers.cbegin();
// *it = 10; // Ошибка компиляции

const std::vector<int>::iterator it1 = vec.begin();  // Нельзя менять it1
*it1 = 42;  // Но можно менять значение
std::vector<int>::const_iterator it2 = vec.cbegin(); // Нельзя менять значение
++it2;      // Но можно менять сам итератор

template<typename T>
class custom_iterator {
    T* ptr;
public:
    T& operator*() { return *ptr; }
    const T& operator*() const { return *ptr; }
    // Остальные операторы...
};

void process_data(const std::vector<int>& data) {
    std::for_each(std::execution::par, 
                  data.cbegin(), data.cend(),
                  [](const int& value) {
        // Гарантированно безопасный параллельный доступ
    });
}

auto it = std::as_const(container).begin();  // Всегда const_iterator
decltype(auto) ref = *it;  // const T&

template<typename It>
concept MutableIterator = std::input_iterator<It> &&
    std::is_same_v<
        std::remove_reference_t<std::iter_reference_t<It>>,
        std::remove_const_t<std::remove_reference_t<std::iter_reference_t<It>>>
    >;

template<typename Container>
class const_window_view {
    const Container& container;
    size_t offset, size;
public:
    auto begin() const { 
        return std::next(container.cbegin(), offset);
    }
    auto end() const {
        return std::next(container.cbegin(), offset + size);
    }
};

template<typename FwdIt>
void stable_unique(FwdIt first, FwdIt last) {
    if (first == last) return;
    
    FwdIt result = first;
    while (++first != last) {
        if (*result != *first && ++result != first) {
            *result = std::move(*first);
        }
    }
}

std::vector<std::unique_ptr<int>> ptrs;
// std::vector<std::unique_ptr<int>>::const_iterator не позволит
// перемещать unique_ptr, только читать значение
for (const auto& ptr : ptrs) {
    // ptr->modify(); // Ошибка компиляции
}

std::vector<int> vec = {1, 2, 3, 4, 5};
auto view = vec | std::views::filter([](int x) { return x % 2 == 0; });
// Тип элементов view зависит от константности vec

template<typename Range>
bool has_duplicates(const Range& range) {
    auto first = std::begin(range);
    auto last = std::end(range);
    return std::adjacent_find(first, last) != last;
}

template<typename Container>
void print_elements(const Container& c) {
    // Компилятор подскажет, если случайно попытаемся 
    // модифицировать элементы
    std::for_each(c.begin(), c.end(), 
                  [](const auto& x) { std::cout << x << ' '; });
}

template<typename It1, typename It2>
class zip_iterator {
    It1 first;
    It2 second;
public:
    using value_type = std::pair<
        typename std::iterator_traits<It1>::value_type,
        typename std::iterator_traits<It2>::value_type
    >;
    
    zip_iterator(It1 it1, It2 it2) : first(it1), second(it2) {}
    
    value_type operator*() { return {*first, *second}; }
    
    zip_iterator& operator++() {
        ++first;
        ++second;
        return *this;
    }
    
    bool operator!=(const zip_iterator& other) const {
        return first != other.first && second != other.second;
    }
};

template<typename Iterator, typename Predicate>
class filter_iterator {
    Iterator current;
    Iterator end;
    Predicate pred;
    
    void skip_until_valid() {
        while (current != end && !pred(*current)) {
            ++current;
        }
    }
    
public:
    filter_iterator(Iterator begin, Iterator end, Predicate p)
        : current(begin), end(end), pred(p) {
        skip_until_valid();
    }
    
    auto operator*() const { return *current; }
    
    filter_iterator& operator++() {
        ++current;
        skip_until_valid();
        return *this;
    }
    
    bool operator!=(const filter_iterator& other) const {
        return current != other.current;
    }
};

template<typename T, typename Generator>
class generator_iterator {
    T current;
    Generator gen;
    
public:
    generator_iterator(Generator g) : gen(g) {
        current = gen();
    }
    
    T operator*() const { return current; }
    
    generator_iterator& operator++() {
        current = gen();
        return *this;
    }
    
    bool operator!=(const generator_iterator&) const { return true; }
};

template<typename Iterator>
class chunk_iterator {
    Iterator start;
    Iterator end;
    size_t chunk_size;
    size_t current_pos;
    
public:
    chunk_iterator(Iterator begin, Iterator end, size_t size)
        : start(begin), end(end), chunk_size(size), current_pos(0) {}
        
    auto operator*() {
        auto chunk_end = start;
        std::advance(chunk_end, std::min(chunk_size, 
            static_cast<size_t>(std::distance(start, end))));
        return std::make_pair(start, chunk_end);
    }
    
    chunk_iterator& operator++() {
        std::advance(start, chunk_size);
        current_pos += chunk_size;
        return *this;
    }
};

template<typename Node>
class depth_first_iterator {
    std::stack<Node*> path;
    
public:
    depth_first_iterator(Node* root) {
        if (root) path.push(root);
    }
    
    Node& operator*() { return *path.top(); }
    
    depth_first_iterator& operator++() {
        Node* current = path.top();
        path.pop();
        
        for (auto it = current->children.rbegin(); 
             it != current->children.rend(); ++it) {
            path.push(*it);
        }
        return *this;
    }
    
    bool operator!=(const depth_first_iterator& other) const {
        return !path.empty() || !other.path.empty();
    }
};

template<typename Iterator>
class sliding_window_iterator {
    Iterator current;
    size_t window_size;
    std::vector<typename std::iterator_traits<Iterator>::value_type> buffer;
    
public:
    sliding_window_iterator(Iterator begin, size_t size)
        : current(begin), window_size(size) {
        for (size_t i = 0; i < size && current != Iterator{}; ++i) {
            buffer.push_back(*current++);
        }
    }
    
    const auto& operator*() const { return buffer; }
    
    sliding_window_iterator& operator++() {
        buffer.erase(buffer.begin());
        if (current != Iterator{}) {
            buffer.push_back(*current++);
        }
        return *this;
    }
};

template<typename T>
class sparse_matrix_iterator {
    std::map<std::pair<size_t, size_t>, T>& data;
    typename std::map<std::pair<size_t, size_t>, T>::iterator current;
    
public:
    sparse_matrix_iterator(std::map<std::pair<size_t, size_t>, T>& m)
        : data(m), current(data.begin()) {}
        
    auto operator*() const {
        return std::make_tuple(
            current->first.first,
            current->first.second,
            current->second
        );
    }
    
    sparse_matrix_iterator& operator++() {
        ++current;
        return *this;
    }
};

template<typename T>
class threadsafe_queue_iterator {
    std::queue<T>& queue;
    mutable std::mutex mutex;
    std::condition_variable not_empty;
 
public:
    threadsafe_queue_iterator(std::queue<T>& q) : queue(q) {}
 
    std::optional<T> operator*() const {
        std::unique_lock lock(mutex);
        if (queue.empty()) return std::nullopt;
        return queue.front();
    }
 
    threadsafe_queue_iterator& operator++() {
        std::unique_lock lock(mutex);
        if (!queue.empty()) queue.pop();
        return *this;
    }
 
    void push(T value) {
        std::unique_lock lock(mutex);
        queue.push(std::move(value));
        not_empty.notify_one();
    }
};

class directory_iterator {
    std::stack<std::filesystem::path> paths;
    std::filesystem::path current;
 
public:
    directory_iterator(const std::filesystem::path& root) {
        if (std::filesystem::is_directory(root))
            paths.push(root);
    }
 
    std::filesystem::path operator*() const { return current; }
 
    directory_iterator& operator++() {
        if (!paths.empty()) {
            current = paths.top();
            paths.pop();
            
            for (const auto& entry : std::filesystem::directory_iterator(current)) {
                if (std::filesystem::is_directory(entry))
                    paths.push(entry.path());
            }
        }
        return *this;
    }
};

template<typename Key, typename Value>
class cached_iterator {
    std::unordered_map<Key, Value>& cache;
    std::function<Value(Key)> loader;
    Key current_key;
 
public:
    cached_iterator(
        std::unordered_map<Key, Value>& c,
        std::function<Value(Key)> l,
        Key start
    ) : cache(c), loader(l), current_key(start) {}
 
    Value& operator*() {
        if (auto it = cache.find(current_key); it == cache.end()) {
            return cache.emplace(current_key, loader(current_key)).first->second;
        } else {
            return it->second;
        }
    }
 
    cached_iterator& operator++() {
        ++current_key;
        return *this;
    }
};

template<typename Iterator>
class moving_average_iterator {
    Iterator current;
    size_t window_size;
    double sum = 0;
    std::queue<double> values;
 
public:
    moving_average_iterator(Iterator begin, size_t size)
        : current(begin), window_size(size) {}
 
    double operator*() const {
        return sum / values.size();
    }
 
    moving_average_iterator& operator++() {
        if (values.size() == window_size) {
            sum -= values.front();
            values.pop();
        }
        sum += *current;
        values.push(*current);
        ++current;
        return *this;
    }
};

template<typename Iterator, typename Aggregator>
class time_series_iterator {
    Iterator current;
    std::chrono::seconds interval;
    Aggregator aggregator;
    std::vector<typename Iterator::value_type> buffer;
 
public:
    time_series_iterator(
        Iterator begin,
        std::chrono::seconds i,
        Aggregator agg
    ) : current(begin), interval(i), aggregator(agg) {}
 
    auto operator*() const {
        return aggregator(buffer.begin(), buffer.end());
    }
 
    time_series_iterator& operator++() {
        auto interval_start = current->timestamp;
        buffer.clear();
        
        while (current->timestamp - interval_start < interval) {
            buffer.push_back(*current);
            ++current;
        }
        return *this;
    }
};

template<typename T>
class timed_buffer_iterator {
    std::deque<std::pair<std::chrono::steady_clock::time_point, T>>& buffer;
    std::chrono::seconds lifetime;
 
    void cleanup() {
        auto now = std::chrono::steady_clock::now();
        while (!buffer.empty() && 
               now - buffer.front().first > lifetime) {
            buffer.pop_front();
        }
    }
 
public:
    timed_buffer_iterator(
        std::deque<std::pair<std::chrono::steady_clock::time_point, T>>& b,
        std::chrono::seconds life
    ) : buffer(b), lifetime(life) {
        cleanup();
    }
 
    T& operator*() {
        cleanup();
        return buffer.back().second;
    }
 
    timed_buffer_iterator& operator++() {
        cleanup();
        if (!buffer.empty()) buffer.pop_back();
        return *this;
    }
};

template<typename... Types>
class variant_container_iterator {
    std::vector<std::variant<Types...>>& container;
    size_t position;
public:
    variant_container_iterator(std::vector<std::variant<Types...>>& cont, size_t pos = 0)
        : container(cont), position(pos) {}
        
    auto operator*() {
        return std::visit([](auto&& arg) -> std::variant<Types...>& {
            return arg;
        }, container[position]);
    }
    
    variant_container_iterator& operator++() {
        ++position;
        return *this;
    }
};

template<typename T>
class async_data_iterator {
    std::shared_ptr<DataSource> source;
    size_t batch_size;
    std::queue<T> buffer;
    
    void fetch_next_batch() {
        auto future = source->async_fetch(batch_size);
        auto data = future.get();
        for (auto& item : data) {
            buffer.push(std::move(item));
        }
    }
    
public:
    T operator*() {
        if (buffer.empty()) {
            fetch_next_batch();
        }
        return buffer.front();
    }
    
    async_data_iterator& operator++() {
        buffer.pop();
        return *this;
    }
};

template<typename T>
class stream_processing_iterator {
    std::function<T()> stream_reader;
    std::chrono::milliseconds timeout;
    T current_value;
    
public:
    stream_processing_iterator(
        std::function<T()> reader,
        std::chrono::milliseconds t
    ) : stream_reader(reader), timeout(t) {
        current_value = stream_reader();
    }
    
    T operator*() const {
        return current_value;
    }
    
    stream_processing_iterator& operator++() {
        auto start = std::chrono::steady_clock::now();
        while (true) {
            if (auto value = stream_reader()) {
                current_value = *value;
                break;
            }
            if (std::chrono::steady_clock::now() - start > timeout) {
                throw std::runtime_error("Stream timeout");
            }
        }
        return *this;
    }
};

template<typename DataSet>
class batch_iterator {
    DataSet& dataset;
    size_t batch_size;
    size_t current_index;
    std::mt19937 rng;
    
public:
    auto operator*() {
        std::vector<typename DataSet::value_type> batch;
        for (size_t i = 0; i < batch_size; ++i) {
            size_t idx = std::uniform_int_distribution<size_t>(
                0, dataset.size() - 1)(rng);
            batch.push_back(dataset[idx]);
        }
        return batch;
    }
    
    batch_iterator& operator++() {
        current_index += batch_size;
        return *this;
    }
};

template<typename Graph>
class graph_traversal_iterator {
    enum class TraversalType { BFS, DFS };
    Graph& graph;
    TraversalType type;
    std::unordered_set<int> visited;
    std::variant<std::queue<int>, std::stack<int>> container;
    
public:
    int operator*() const {
        if (type == TraversalType::BFS) {
            return std::get<std::queue<int>>(container).front();
        } else {
            return std::get<std::stack<int>>(container).top();
        }
    }
    
    graph_traversal_iterator& operator++() {
        int current = **this;
        if (type == TraversalType::BFS) {
            std::get<std::queue<int>>(container).pop();
        } else {
            std::get<std::stack<int>>(container).pop();
        }
        
        for (int neighbor : graph.get_neighbors(current)) {
            if (visited.insert(neighbor).second) {
                if (type == TraversalType::BFS) {
                    std::get<std::queue<int>>(container).push(neighbor);
                } else {
                    std::get<std::stack<int>>(container).push(neighbor);
                }
            }
        }
        return *this;
    }
};

template<typename T>
class observable_iterator {
    std::vector<T>& data;
    size_t position;
    std::vector<std::function<void(const T&)>> observers;
    
public:
    T& operator*() {
        T& value = data[position];
        for (auto& observer : observers) {
            observer(value);
        }
        return value;
    }
    
    void add_observer(std::function<void(const T&)> observer) {
        observers.push_back(observer);
    }
    
    observable_iterator& operator++() {
        ++position;
        return *this;
    }
};

template<typename Iterator, typename Cipher>
class encrypting_iterator {
    Iterator source;
    Cipher cipher;
    std::vector<uint8_t> buffer;
    
public:
    auto operator*() {
        if (buffer.empty()) {
            buffer = cipher.encrypt(*source);
        }
        return buffer.front();
    }
    
    encrypting_iterator& operator++() {
        if (!buffer.empty()) {
            buffer.erase(buffer.begin());
        }
        if (buffer.empty()) {
            ++source;
        }
        return *this;
    }
};