Представления как элементы данных для пользовательских итераторов - Введение

// Типичный код без пользовательского итератора
std::vector<std::vector<int>> data = {{1, 2}, {3}, {}, {4, 5, 6}};
for (const auto& outer : data) {
    for (const auto& inner : outer) {
        process(inner); // Обработка каждого элемента
    }
}

std::vector<int> v = {1, 2, 3, 4, 5};
std::vector<int> result;
std::transform(v.begin(), v.end(), std::back_inserter(result), 
               [](int i) { return i * i; });
std::vector<int> filtered;
std::copy_if(result.begin(), result.end(), std::back_inserter(filtered),
             [](int i) { return i > 10; });

auto result = v | std::views::transform([](int i) { return i * i; })
               | std::views::filter([](int i) { return i > 10; });
for (int i : result) {
    use(i);
}

template <std::ranges::range R>
class MyCustomIterator {
    // ...
};

template <typename Container, 
         typename = typename std::enable_if<
             has_begin_end<Container>::value &&
             !is_associative_container<Container>::value
         >::type>
class GenericIterator {
// ...много-много кода с SFINAE и static_assert
};

template <typename Container> 
requires std::ranges::range<Container> && !is_associative_v<Container>
class GenericIterator {
// ... гораздо более чистый код
};

// Контейнер - владеет данными
std::vector<int> nums = {1, 2, 3, 4, 5};
 
// Представление - не владеет данными, просто "смотрит" на них
auto even_nums = nums | std::views::filter([](int n) { return n % 2 == 0; });

// Старый подход - создаем временные коллекции на каждом шаге
std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
std::vector<int> squares;
for (int n : numbers) {
    squares.push_back(n * n);
}
std::vector<int> even_squares;
for (int sq : squares) {
    if (sq % 2 == 0) {
        even_squares.push_back(sq);
    }
}

auto result = numbers | std::views::transform([](int n) { return n * n; })
                     | std::views::filter([](int sq) { return sq % 2 == 0; });

auto interesting_data = data 
    | std::views::filter([](auto& item) { return item.is_valid(); })
    | std::views::transform([](auto& item) { return process(item); })
    | std::views::take(10);

template<class T>
concept view =
  range<T> &&
  movable<T> &&
  default_initializable<T> &&
  enable_view<T>;

template <std::ranges::view V>
void process_view(V v) {
    // Можем быть уверены, что V - представление
    for (auto&& item : v) {
        use(item);
    }
}

template <std::ranges::view V>
class CachingView : public std::ranges::view_interface<CachingView<V>> {
private:
    V base_;
    mutable std::vector<std::ranges::range_value_t<V>> cache_;
    mutable bool initialized_ = false;
 
    void initialize() const {
        if (!initialized_) {
            cache_.assign(std::ranges::begin(base_), std::ranges::end(base_));
            initialized_ = true;
        }
    }
 
public:
    explicit CachingView(V base) : base_(std::move(base)) {}
 
    auto begin() const {
        initialize();
        return cache_.begin();
    }
 
    auto end() const {
        initialize();
        return cache_.end();
    }
};

std::ranges::view auto get_view() {
    std::vector<int> vec = {1, 2, 3, 4, 5}; // Создается локально
    return vec | std::views::filter([](int x) { return x % 2 == 0; }); // Опасно!
}
 
auto v = get_view(); // v ссылается на уничтоженный вектор
for (int x : v) { // Неопределенное поведение
    std::cout << x << ' ';
}

std::ranges::view auto apply_filter(std::ranges::range auto& r) {
    return r | std::views::filter([](int x) { return x % 2 == 0; });
}
 
std::vector<int> vec = {1, 2, 3, 4, 5}; // Создается на стеке
auto v = apply_filter(vec); // v ссылается на vec
// v действительно, пока действителен vec

std::ranges::view auto create_pipeline() {
    // Никаких копий при возврате из функции
    return std::views::iota(1, 100) 
         | std::views::filter([](int n) { return n % 7 == 0; })
         | std::views::transform([](int n) { return n * n; });
}
 
auto pipeline = create_pipeline(); // Опять же, никаких копий

// Этот код с представлениями...
auto result = data | std::views::filter(pred1)
                  | std::views::transform(func1)
                  | std::views::filter(pred2)
                  | std::views::transform(func2);
 
// ...после оптимизации часто превращается в эквивалент:
for (const auto& item : data) {
    if (pred1(item)) {
        auto tmp1 = func1(item);
        if (pred2(tmp1)) {
            use(func2(tmp1));
        }
    }
}

template <std::ranges::input_range V>
requires std::ranges::view<V>
class enumerate_view : public std::ranges::view_interface<enumerate_view<V>> {
private:
    V base_ = V();
    using inner_iterator = std::ranges::iterator_t<V>;
    
    class iterator {
    private:
        inner_iterator inner_;
        std::size_t index_ = 0;
    public:
        using value_type = std::pair<std::size_t, std::ranges::range_value_t<V>>;
        
        explicit iterator(inner_iterator it) : inner_(std::move(it)) {}
        
        value_type operator*() const {
            return {index_, *inner_};
        }
        
        iterator& operator++() {
            ++inner_;
            ++index_;
            return *this;
        }
        
        // Другие необходимые операторы...
    };
    
public:
    enumerate_view() = default;
    explicit enumerate_view(V base) : base_(std::move(base)) {}
    
    auto begin() { return iterator(std::ranges::begin(base_)); }
    auto end() { return iterator(std::ranges::end(base_)); }
};
 
// Удобный шаблон-переменная для создания экземпляров
template <std::ranges::range R>
auto enumerate(R&& r) {
    return enumerate_view(std::views::all(std::forward<R>(r)));
}

std::vector<std::string> words = {"яблоко", "банан", "киви"};
auto indexed_words = enumerate(words);
for (auto [idx, word] : indexed_words) {
    std::cout << idx << ": " << word << '\n';
}

std::vector<int> nums = {1, 2, 3, 4, 5};
auto view = nums | std::views::filter([](int& x) { return x % 2 == 1; });
 
// Модификация через представление
for (int& x : view) {
    x *= 10;
}
 
// Выведет: 10, 2, 30, 4, 50
for (int x : nums) {
    std::cout << x << ' ';
}

std::list<std::string> words = {"hello", "world"};
auto copied = words | std::views::transform([](const std::string& s) { return s + "!"; });
 
// Ошибка компиляции: нельзя модифицировать временный объект
for (std::string& s : copied) {
    s = s.substr(0, 3);
}

generator<int> fibonacci() {
    int a = 0, b = 1;
    while (true) {
        co_yield a;
        auto next = a + b;
        a = b;
        b = next;
    }
}
 
void use_fibonacci() {
    auto fibs = fibonacci() | std::views::take(10);
    for (int x : fibs) {
        std::cout << x << ' ';  // Выведет первые 10 чисел Фибоначчи
    }
}

// Представление с дорогими операциями
auto expensive_view = data | std::views::transform([](auto x) { 
    // Дорогая операция
    return compute_hash(x); 
});
 
// Если нужно многократно пройти по результатам, лучше материализовать
std::vector<hash_t> materialized(expensive_view.begin(), expensive_view.end());