Я хочу показать, как создать собственный итератор, используя представления в качестве членов класса. Для меня этот подход стал настоящим откровением, когда я пытался решить классическую проблему обхода вложенных структур данных.
Итератор для вектора векторов
Представьте типичную задачу с собеседования: у вас есть вектор векторов, и вам нужно реализовать итератор, который позволит пройти по всем элементам "насквозь", словно это один плоский массив. Например:
| C++ | 1
2
| std::vector<std::vector<int>> input = {{1, 2}, {3}, {}, {4, 5, 6}};
// Нужно пройти в порядке: 1, 2, 3, 4, 5, 6 |
|
Традиционный подход к реализации
Вот как выглядело бы традиционное решение (я специально опускаю некоторые детали для краткости):
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
| class TwoDIterator {
public:
using Vec2D = std::vector<std::vector<int>>;
TwoDIterator(const Vec2D& data)
: data_(data), outer_(0), inner_(0) {
advance_to_next_valid();
}
bool has_next() const {
return outer_ < data_.size();
}
int next() {
if (!has_next()) throw std::out_of_range("No more elements");
int val = data_[outer_][inner_];
++inner_;
advance_to_next_valid();
return val;
}
private:
void advance_to_next_valid() {
while (outer_ < data_.size() && inner_ >= data_[outer_].size()) {
++outer_;
inner_ = 0;
}
}
const Vec2D& data_;
size_t outer_, inner_;
}; |
|
1. Много бойлерплейта для обработки граничных случаев,
2. Сложно расширять для других типов контейнеров,
3. Нет поддержки стандартных итераторных операций (нельзя использовать в алгоритмах STL).
Преобразование с использованием представлений
А теперь представьте, что можно решить эту же задачу, используя представления из C++20. Вместо хранения индексов и ручного прыгания по границам, мы просто используем готовый механизм join_view:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
| #include <ranges>
class TwoDIteratorJoin {
public:
using Vec2D = std::vector<std::vector<int>>;
using JoinView = std::ranges::join_view<std::ranges::ref_view<const Vec2D>>;
using Iterator = std::ranges::iterator_t<JoinView>;
explicit TwoDIteratorJoin(const Vec2D& data)
: flattened_(data | std::views::join),
iter_(flattened_.begin()),
end_(flattened_.end()) {}
bool has_next() const {
return iter_ != end_;
}
int next() {
if (!has_next()) throw std::out_of_range("No more elements");
return *iter_++;
}
private:
JoinView flattened_;
Iterator iter_, end_;
}; |
|
| C++ | 1
| auto flat = nested | std::views::join; // ошибка: не можем использовать auto для членов класса |
|
auto для членов класса - нам нужно точно указать тип. И вот тут начинается самое интересное.
Правильное объявление типов представлений
Чтобы использовать представление в качестве члена класса, нам нужно точно знать его тип. А типы представлений в C++20... ну, скажем так, они не из тех, что захочется писать вручную. Рассмотрим шаг за шагом:
1. Тип нашего контейнера: std::vector<std::vector<int>>
2. Но join_view требует view, а не контейнер, поэтому нам сначала нужно обернуть контейнер в ref_view:
std::ranges::ref_view<const Vec2D>
3. Затем применить join_view к этому ref_view:
std::ranges::join_view<std::ranges::ref_view<const Vec2D>>
Заметьте, насколько это сложнее, чем просто написать auto flat = nested | std::views::join. Но такова цена использования представлений как членов класса.
Еще один нюанс - мы используем const Vec2D& в ref_view, потому что хотим, чтобы наш итератор не модифицировал исходные данные. Если вам нужна модификация, используйте Vec2D& без const.
Понимание жизненного цикла представлений
Когда мы храним представление как член класса, нужно быть особенно внимательным к жизненному циклу базовых данных. В нашем примере TwoDIteratorJoin хранит представление, которое ссылается на внешний Vec2D. Если этот внешний вектор будет уничтожен, наше представление станет недействительным - классическая проблема висячих ссылок.
| C++ | 1
2
3
4
| TwoDIteratorJoin bad_idea() {
std::vector<std::vector<int>> local_data = {{1, 2}, {3}}; // Локальная переменная
return TwoDIteratorJoin(local_data); // Опасно! local_data будет уничтожен
} |
|
Реализация стандартных итераторных интерфейсов
Наш TwoDIteratorJoin пока не совсем стандартный итератор - он имеет интерфейс has_next() и next(), что удобно для некоторых ситуаций, но не позволяет использовать его в стандартных алгоритмах.
Чтобы создать полноценный итератор, совместимый с STL, нам нужно реализовать правильный интерфейс. Вот как может выглядеть более полная версия:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| template <typename T>
class FlattenedRange {
public:
using Vec2D = std::vector<std::vector<T>>;
using JoinView = std::ranges::join_view<std::ranges::ref_view<const Vec2D>>;
explicit FlattenedRange(const Vec2D& data) : flat_view_(data | std::views::join) {}
auto begin() const { return flat_view_.begin(); }
auto end() const { return flat_view_.end(); }
// Для совместимости со старым кодом
bool has_next() const { return current_ != flat_view_.end(); }
T next() {
if (!has_next()) throw std::out_of_range("No more elements");
return *current_++;
}
private:
JoinView flat_view_;
std::ranges::iterator_t<JoinView> current_ = flat_view_.begin();
}; |
|
| C++ | 1
2
3
4
| FlattenedRange<int> range(nested_vector);
while (range.has_next()) {
process(range.next());
} |
|
| C++ | 1
2
3
4
5
6
| FlattenedRange<int> range(nested_vector);
for (auto value : range) {
process(value);
}
std::ranges::for_each(range, process); |
|
Наследование от view_interface для полной поддержки ranges
Чтобы создать по-настоящему совместимый с ranges тип, мы можем унаследоваться от std::ranges::view_interface. Этот класс предоставляет множество полезных функций, реализованных поверх базовых begin() и end():
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| template <typename T>
class FlattenedView : public std::ranges::view_interface<FlattenedView<T>> {
public:
using Vec2D = std::vector<std::vector<T>>;
using JoinView = std::ranges::join_view<std::ranges::ref_view<const Vec2D>>;
FlattenedView() = default;
explicit FlattenedView(const Vec2D& data) : data_(&data),
flat_view_(std::ranges::ref_view(*data_) | std::views::join) {}
auto begin() const { return flat_view_.begin(); }
auto end() const { return flat_view_.end(); }
bool empty() const { return begin() == end(); }
// Можно добавить дополнительные удобные методы
auto size() const requires std::ranges::sized_range<JoinView> {
return std::ranges::size(flat_view_);
}
private:
const Vec2D* data_ = nullptr;
JoinView flat_view_ = JoinView(std::ranges::ref_view<const Vec2D>(*data_));
}; |
|
| C++ | 1
2
| auto result = FlattenedView(nested_vector) | std::views::filter(is_even)
| std::views::transform(square); |
|
Обработка состояний и границ диапазона
Одна из самых сложных частей при создании итераторов - правильная обработка граничных случаев. Что, если контейнер пуст? Что, если все внутренние контейнеры пусты? С представлениями большая часть этой логики уже реализована за нас.
Например, join_view автоматически пропускает пустые внутренние диапазоны и корректно обрабатывает случай, когда внешний диапазон пуст. Это избавляет нас от написания кучи проверок, которые легко сделать неправильно.
Еще одно преимущество - внутренние итераторы представлений уже реализуют правильную семантику для операторов ++, --, == и других. Нам не нужно беспокоиться о тонких деталях, например, о том, что итератор должен быть равен end() после последнего элемента.
Поддержка различных категорий итераторов
В зависимости от базового диапазона, наш итератор может поддерживать разные категории итераторов - от input_iterator до random_access_iterator.
С представлениями мы автоматически получаем максимально возможную категорию, основанную на исходных данных. Например, если наш Vec2D позволяет произвольный доступ (что верно для std::vector), то итераторы join_view будут иметь как минимум категорию bidirectional_iterator. Это дает нам возможность использовать операторы -- для движения назад:
| C++ | 1
2
3
| auto it = flattened.begin();
++it; ++it; // Перешли к третьему элементу
--it; // Вернулись ко второму |
|
Оптимизация с помощью концептов
Концепты в C++20 не только улучшают читаемость кода, но и помогают оптимизировать его. Например, мы можем условно добавлять функциональность в зависимости от возможностей базового диапазона:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| template <typename T>
class EnhancedFlattenedView : public std::ranges::view_interface<EnhancedFlattenedView<T>> {
// ...базовая реализация...
// Добавляем метод size() только если базовый диапазон поддерживает его
auto size() const requires std::ranges::sized_range<JoinView> {
return std::ranges::size(flat_view_);
}
// Добавляем оператор [] только для random access диапазонов
auto operator[](std::size_t n) const
requires std::ranges::random_access_range<JoinView> {
return flat_view_[n];
}
}; |
|
Безопасность и обработка исключений
Работа с представлениями в целом более безопасна, чем ручная реализация итераторов, но все же есть места, где нужно быть осторожным. Главная проблема - жизненный цикл данных. Представления хранят ссылки, а не копии, поэтому они становятся недействительными, если базовые данные уничтожены. Это классическая проблема dangling references. Чтобы обезопасить себя, можно:
1. Явно документировать, что пользователь несет ответственность за жизненный цикл данных.
2. Реализовать проверки во время выполнения (хотя это снижает производительность).
3. В крайнем случае, хранить копию данных вместо ссылки.
Что касается исключений, то большинство операций с представлениями не генерируют исключений, если базовые операции их не генерируют. Это делает код более предсказуемым и надежным.
Интеграция с алгоритмами ranges
Один из главных бонусов создания итератора на основе представлений - автоматическая совместимость с алгоритмами ranges. Например:
| C++ | 1
2
3
4
5
6
7
| std::vector<std::vector<int>> nested = {{1, 2}, {3, 4}, {5, 6}};
auto flattened = FlattenedView(nested);
// Можем использовать любые алгоритмы ranges
auto sum = std::ranges::fold_left(flattened, 0, std::plus<>{});
auto [min, max] = std::ranges::minmax(flattened);
bool all_positive = std::ranges::all_of(flattened, [](int x) { return x > 0; }); |
|
Гибкие итераторы для нестандартных структур данных
Помимо простого обхода вложенных векторов, подход с использованием представлений открывает потрясающие возможности для создания итераторов над нестандартными структурами данных. Я часто сталкиваюсь с задачами, где нужно обходить какую-нибудь хитрую структуру - деревья, графы, разреженные матрицы и так далее. Например, с представлениями реализация обхода дерева в порядке in-order становится поразительно простой:
| C++ | 1
2
3
4
5
6
7
8
| template <std::ranges::range Tree>
auto in_order_view(const Tree& tree) {
if (tree.empty()) return std::views::empty<typename Tree::value_type>();
return in_order_view(tree.left)
| std::views::single(tree.value)
| in_order_view(tree.right);
} |
|
Комбинирование с корутинами для сложных порядков обхода
C++20 представил не только диапазоны, но и корутины. И, честно говоря, их комбинация - это просто феерия. Корутины позволяют описывать сложные порядки обхода в стиле, похожем на генераторы в Python:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
| generator<int> spiral_order(const std::vector<std::vector<int>>& matrix) {
if (matrix.empty()) co_return;
int left = 0, right = matrix[0].size() - 1;
int top = 0, bottom = matrix.size() - 1;
while (left <= right && top <= bottom) {
// Верхняя строка слева направо
for (int col = left; col <= right; col++)
co_yield matrix[top][col];
top++;
// Правый столбец сверху вниз
for (int row = top; row <= bottom; row++)
co_yield matrix[row][right];
right--;
// Нижняя строка справа налево (если осталась)
if (top <= bottom) {
for (int col = right; col >= left; col--)
co_yield matrix[bottom][col];
bottom--;
}
// Левый столбец снизу вверх (если остался)
if (left <= right) {
for (int row = bottom; row >= top; row--)
co_yield matrix[row][left];
left++;
}
}
} |
|
| C++ | 1
| auto spiral = spiral_order(matrix) | std::views::take(10); // Первые 10 элементов в спиральном порядке |
|
Адаптация legacy-кода к представлениям
Во многих проектах уже есть куча legacy-итераторов, и переписывать их все разом - затея нереалистичная. К счастью, можно создать обертки, которые превращают существующие итераторы в представления:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| template <typename Iterator>
class iterator_pair_view : public std::ranges::view_interface<iterator_pair_view<Iterator>> {
private:
Iterator begin_;
Iterator end_;
public:
iterator_pair_view(Iterator begin, Iterator end)
: begin_(std::move(begin)), end_(std::move(end)) {}
auto begin() const { return begin_; }
auto end() const { return end_; }
};
// Удобная функция-фабрика
template <typename Iterator>
auto make_view(Iterator begin, Iterator end) {
return iterator_pair_view<Iterator>(std::move(begin), std::move(end));
} |
|
| C++ | 1
2
3
| auto old_begin = legacy_collection.begin();
auto old_end = legacy_collection.end();
auto modern_view = make_view(old_begin, old_end) | std::views::filter(is_valid); |
|
Многомерные представления и итераторы
С появлением многомерных представлений в C++23 (например, mdspan) мы получаем еще больше возможностей для создания эффективных итераторов над многомерными структурами. Но даже с C++20 можно создавать гибкие абстракции для работы с многомерными данными:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
| template <typename T, size_t Dims>
class MDView {
// Различные представления многомерного массива
auto flat_view() {
return data_ | std::views::all; // Сплющенное представление
}
auto axis_view(size_t axis, size_t index) {
// Представление конкретного "среза" по заданной оси
// ...
}
// Другие специализированные представления
}; |
|
Итераторы для струкутр "только для чтения"
Иногда нам нужно создать итератор для структуры, которая не предоставляет прямого доступа к своему содержимому или делает это неэффективно. Представления помогают и здесь. Например, я однажды работал с криптографической структурой, которая позволяла получать значения только последовательно, без произвольного доступа (из соображений безопасности). С представлениями я создал итератор, который кэшировал значения при первом доступе:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
| template <typename Source>
class CachingIteratorView : public std::ranges::view_interface<CachingIteratorView<Source>> {
private:
Source source_;
mutable std::vector<typename Source::value_type> cache_;
void ensure_cached(size_t index) const {
while (cache_.size() <= index && source_.has_next()) {
cache_.push_back(source_.next());
}
}
public:
explicit CachingIteratorView(Source source) : source_(std::move(source)) {}
auto operator[](size_t index) const {
ensure_cached(index);
if (index >= cache_.size()) {
throw std::out_of_range("Index out of range");
}
return cache_[index];
}
auto begin() const {
// Возвращаем итератор, использующий ensure_cached
// ...
}
auto end() const {
// Конечный итератор
// ...
}
}; |
|
Отложенная инициализация итераторов
Еще одна интересная возможность - создание итераторов с отложенной инициализацией. Это полезно, когда создание итератора дорого, но мы не знаем, будут ли фактически использованы все элементы.
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
| template <typename Factory>
class LazyView : public std::ranges::view_interface<LazyView<Factory>> {
private:
Factory factory_;
mutable std::optional<std::invoke_result_t<Factory>> view_;
void ensure_initialized() const {
if (!view_) {
view_ = factory_();
}
}
public:
explicit LazyView(Factory factory) : factory_(std::move(factory)) {}
auto begin() const {
ensure_initialized();
return view_->begin();
}
auto end() const {
ensure_initialized();
return view_->end();
}
};
// Использование
auto expensive_view = LazyView([]() {
std::cout << "Creating expensive view...";
return expensive_computation() | std::views::transform(process);
});
// View не будет создан, пока мы не начнем итерацию
if (condition) {
for (auto item : expensive_view) {
use(item);
}
} |
|
condition ложно - вот что значит настоящая ленивость! Нам удалось превратить десятки (а иногда и сотни) строк запутанного кода в компактные, выразительные и эффективные итераторы-представления. Такое использование C++20 не просто делает код чище - оно позволяет более четко выразить намерения и сконцентрироваться на реальной бизнес-логике вместо возни с технической реализацией итераторов.
Практические сценарии применения
Теория - это здорово, но давайте взглянем на реальные сценарии, где представления в качестве элементов данных итераторов действительно показывают себя во всей красе. Я расскажу о тех случаях, где сам применял этот подход, и полученных результатах.
Фильтрация данных в реальном времени
Когда мы работаем с потоками данных в реальном времени, каждая лишняя аллокация памяти может стать проблемой. Представьте систему мониторинга, обрабатывающую тысячи метрик в секунду, где нам нужны только значения, превышающие определенный порог:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| class MetricsMonitor {
public:
using Metric = std::pair<std::string, double>;
using MetricList = std::vector<Metric>;
// Фильтруем метрики "на лету"
auto critical_metrics(double threshold) {
return metrics_ | std::views::filter([threshold](const Metric& m) {
return m.second > threshold;
});
}
// Обрабатываем только важные метрики без временных коллекций
void process_important() {
for (const auto& metric : critical_metrics(critical_threshold_)) {
alert_system_.send(metric);
}
}
private:
MetricList metrics_;
double critical_threshold_ = 0.95;
AlertSystem alert_system_;
}; |
|
Трансформация больших массивов без копирования
Для работы с большими датасетами (научные вычисления, машинное обучение) копирование данных часто становится узким местом. С представлениями мы можем трансформировать данные "на лету":
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| template <typename T>
class LargeDataProcessor {
public:
// Нормализация данных без копирования
auto normalized_view() {
const T min_val = *std::ranges::min_element(data_);
const T max_val = *std::ranges::max_element(data_);
const T range = max_val - min_val;
return data_ | std::views::transform([min_val, range](T value) {
return (value - min_val) / range;
});
}
// Вычисление статистик на нормализованных данных
T compute_mean() {
auto norm = normalized_view();
T sum = std::accumulate(norm.begin(), norm.end(), T{});
return sum / norm.size();
}
private:
std::vector<T> data_;
}; |
|
Работа с потоками и генераторами
Представления особенно хороши при работе с потенциально бесконечными последовательностями. Вот как можно создать итератор для потока данных:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
| template <typename Source>
class StreamView : public std::ranges::view_interface<StreamView<Source>> {
private:
Source source_;
class iterator {
private:
Source* source_ = nullptr;
std::optional<typename Source::value_type> current_;
public:
using value_type = typename Source::value_type;
using difference_type = std::ptrdiff_t;
iterator() = default;
explicit iterator(Source* source) : source_(source) {
if (source_ && source_->has_next()) {
current_ = source_->next();
} else {
source_ = nullptr; // End iterator
}
}
value_type operator*() const { return *current_; }
iterator& operator++() {
if (source_ && source_->has_next()) {
current_ = source_->next();
} else {
source_ = nullptr; // Достигли конца
}
return *this;
}
// Другие необходимые операторы...
friend bool operator==(const iterator& a, const iterator& b) {
return a.source_ == b.source_;
}
};
public:
explicit StreamView(Source source) : source_(std::move(source)) {}
auto begin() { return iterator(&source_); }
auto end() { return iterator(); }
}; |
|
has_next() и next(). Например, для сетевого потока:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
| // Использование с сетевым потоком
NetworkStream stream = connect_to_server();
StreamView view(stream);
// Берем только первые 100 строк и фильтруем пустые
auto processed = view | std::views::take(100)
| std::views::filter([](const std::string& s) {
return !s.empty();
});
for (const auto& line : processed) {
process_line(line);
} |
|
Интеграция с корутинами для асинхронной обработки
C++20 представил не только диапазоны, но и корутины. Их комбинация открывает впечатляющие возможности для асинхронной обработки данных:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| // Генератор асинхронных значений
cppcoro::generator<DataChunk> async_data_generator(DataSource& source) {
while (source.has_more()) {
// Асинхронно ждем следующий чанк данных
auto chunk = co_await source.next_chunk();
co_yield chunk;
}
}
// Асинхронная обработка данных через представления
cppcoro::task<void> process_data_async(DataSource& source) {
auto generator = async_data_generator(source);
// Создаем представление поверх генератора
auto view = generator | std::views::transform([](const DataChunk& chunk) {
return process_chunk(chunk);
});
// Асинхронно обрабатываем результаты
for (auto&& result : view) {
co_await store_result(result);
}
} |
|
Создание pipeline обработки данных
Одно из самых мощных применений представлений - создание пайплайнов обработки данных, где каждый этап - это представление:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| template <typename DataSource>
class DataPipeline {
public:
explicit DataPipeline(DataSource source) : source_(std::move(source)) {}
// Строим пайплайн обработки данных
template <typename... Operations>
auto build(Operations&&... ops) {
// Начинаем с исходных данных
auto pipeline = source_ | std::views::all;
// Применяем каждую операцию по очереди
// (C++ fold expression для раскрытия параметр-пака)
return (pipeline | ... | std::forward<Operations>(ops));
}
private:
DataSource source_;
}; |
|
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| // Пример использования
void process_log_data(std::vector<LogEntry>& logs) {
DataPipeline pipeline(logs);
// Строим пайплайн: фильтруем ошибки, извлекаем сообщения, удаляем дубликаты
auto processed = pipeline.build(
std::views::filter([](const LogEntry& entry) {
return entry.level == LogLevel::Error;
}),
std::views::transform([](const LogEntry& entry) {
return entry.message;
}),
std::views::unique
);
// Данные обрабатываются только при итерации
for (const auto& error_message : processed) {
report_error(error_message);
}
} |
|
Параллелизация обработки через execution policies
С C++17 у нас есть политики выполнения (execution policies), которые в сочетании с представлениями дают мощный инструмент для параллельной обработки:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| template <typename Range>
void parallel_process(Range&& range) {
// Применяем трансформации с помощью представлений
auto transformed = range | std::views::transform([](auto item) {
return heavy_computation(item);
});
// Материализуем результаты параллельно
std::vector<std::ranges::range_value_t<decltype(transformed)>> results;
results.reserve(std::ranges::distance(transformed));
std::ranges::copy(
std::execution::par_unseq, // Параллельное и векторизованное выполнение
transformed,
std::back_inserter(results)
);
// Дальнейшая обработка результатов
process_results(results);
} |
|
Для научных расчетов, где каждый элемент требует сложных независимых вычислений, такой подход позволял мне загрузить все ядра процессора без явного управления потоками.
Инкрементальная обработка огромных файлов
Когда файл не помещается в память целиком, представления позволяют обрабатывать его порциями:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
| class LargeFileView : public std::ranges::view_interface<LargeFileView> {
private:
std::string filename_;
size_t chunk_size_ = 4096;
class iterator {
private:
std::ifstream file_;
std::vector<char> buffer_;
size_t chunk_size_;
bool is_end_ = false;
public:
using value_type = std::string_view;
iterator() : is_end_(true) {}
iterator(const std::string& filename, size_t chunk_size)
: chunk_size_(chunk_size), buffer_(chunk_size) {
file_.open(filename, std::ios::binary);
if (!file_) {
is_end_ = true;
return;
}
read_next_chunk();
}
void read_next_chunk() {
if (!file_) {
is_end_ = true;
return;
}
file_.read(buffer_.data(), chunk_size_);
std::streamsize bytes_read = file_.gcount();
if (bytes_read == 0) {
is_end_ = true;
} else if (bytes_read < chunk_size_) {
buffer_.resize(bytes_read);
}
}
value_type operator*() const {
return std::string_view(buffer_.data(), buffer_.size());
}
iterator& operator++() {
read_next_chunk();
return *this;
}
friend bool operator==(const iterator& a, const iterator& b) {
return a.is_end_ == b.is_end_;
}
};
public:
explicit LargeFileView(std::string filename, size_t chunk_size = 4096)
: filename_(std::move(filename)), chunk_size_(chunk_size) {}
auto begin() { return iterator(filename_, chunk_size_); }
auto end() { return iterator(); }
}; |
|
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
| // Использование для подсчета строк в большом файле
void count_lines(const std::string& filename) {
LargeFileView chunks(filename);
// Преобразуем чанки в строки и считаем символы переноса строки
size_t line_count = 0;
for (auto chunk : chunks) {
line_count += std::count(chunk.begin(), chunk.end(), '\n');
}
std::cout << "Файл содержит примерно " << line_count << " строк\n";
} |
|
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| // Ищем все вхождения строки в огромном файле
auto find_in_large_file(const std::string& filename, std::string_view needle) {
LargeFileView chunks(filename);
return chunks | std::views::transform([needle](std::string_view chunk) {
// Простая реализация для примера
size_t pos = 0;
std::vector<size_t> positions;
while ((pos = chunk.find(needle, pos)) != std::string_view::npos) {
positions.push_back(pos);
pos += needle.length();
}
return positions;
});
} |
|
Кеширование редко изменяемых данных
Иногда нам приходится работать с данными, которые редко меняются, но часто используются. В таких случаях имеет смысл кешировать результаты первого прохода:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
| 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_ = std::vector<std::ranges::range_value_t<V>>(
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();
}
};
// Удобная функция для создания кеширующего представления
template <std::ranges::view V>
auto make_caching_view(V&& view) {
return CachingView<std::remove_cvref_t<V>>(std::forward<V>(view));
} |
|
Работа с диалоговыми интерфейсами и пользовательским вводом
Представления могут быть полезны даже для систем, взаимодействующих с пользователем. Например, для интерактивного командного интерпретатора:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| class CommandInterpreter {
public:
// Получаем команды пользователя как представление
auto command_stream() {
return std::views::istream<std::string>(std::cin)
| std::views::filter([](const std::string& cmd) {
return !cmd.empty() && cmd != "exit";
});
}
void run() {
std::cout << "Введите команды (exit для выхода):\n";
for (const auto& cmd : command_stream()) {
execute_command(cmd);
}
}
private:
void execute_command(const std::string& cmd) {
// Логика выполнения команд
std::cout << "Выполняю: " << cmd << "\n";
}
}; |
|
Системы событий и реактивное программирование
Говоря о событиях, представления идеально подходят для построения простых реактивных систем:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
| template <typename Event>
class EventStream {
private:
std::vector<Event> events_;
std::mutex mutex_;
std::condition_variable cv_;
bool closed_ = false;
public:
void push(Event event) {
std::lock_guard<std::mutex> lock(mutex_);
events_.push_back(std::move(event));
cv_.notify_one();
}
void close() {
std::lock_guard<std::mutex> lock(mutex_);
closed_ = true;
cv_.notify_all();
}
// Получаем представление потока событий определенного типа
template <typename EventType>
auto view_events() {
return std::views::all(events_)
| std::views::filter([](const Event& e) {
return std::holds_alternative<EventType>(e);
})
| std::views::transform([](const Event& e) {
return std::get<EventType>(e);
});
}
// Ждем и обрабатываем события в отдельном потоке
template <typename Handler>
void process_events(Handler handler) {
std::thread processor([this, handler = std::move(handler)]() {
size_t processed = 0;
while (true) {
std::unique_lock<std::mutex> lock(mutex_);
cv_.wait(lock, [this, processed]() {
return closed_ || processed < events_.size();
});
if (processed < events_.size()) {
auto event = events_[processed++];
lock.unlock();
handler(event);
} else if (closed_) {
break;
}
}
});
processor.detach();
}
}; |
|
Работа с графовыми структурами
Графы — еще одна область, где представления показывают себя великолепно. Вот пример обхода графа в ширину с помощью представлений:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
| template <typename Graph, typename Node>
class BfsView : public std::ranges::view_interface<BfsView<Graph, Node>> {
private:
const Graph* graph_;
Node start_node_;
class iterator {
private:
const Graph* graph_ = nullptr;
std::queue<Node> queue_;
std::unordered_set<Node> visited_;
Node current_;
bool is_end_ = true;
public:
using value_type = Node;
iterator() = default;
iterator(const Graph* graph, Node start)
: graph_(graph), current_(start), is_end_(false) {
visited_.insert(start);
queue_.push(start);
advance(); // Переходим к первому элементу
}
void advance() {
if (queue_.empty()) {
is_end_ = true;
return;
}
current_ = queue_.front();
queue_.pop();
// Добавляем соседей в очередь
for (const Node& neighbor : graph_->neighbors(current_)) {
if (visited_.insert(neighbor).second) {
queue_.push(neighbor);
}
}
}
value_type operator*() const { return current_; }
iterator& operator++() {
advance();
return *this;
}
friend bool operator==(const iterator& a, const iterator& b) {
return a.is_end_ == b.is_end_;
}
};
public:
BfsView(const Graph& graph, Node start)
: graph_(&graph), start_node_(std::move(start)) {}
auto begin() const { return iterator(graph_, start_node_); }
auto end() const { return iterator(); }
}; |
|
| C++ | 1
2
3
4
5
6
7
| Graph g = create_graph();
auto bfs = BfsView(g, start_node)
| std::views::take(100); // Ограничиваем глубину обхода
for (const auto& node : bfs) {
process_node(node);
} |
|
Динамическое построение запросов к данным
В приложениях с динамическими фильтрами (например, UI-приложениях) часто возникает необходимость создавать фильтры "на лету" в зависимости от ввода пользователя:
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
| class DynamicQueryBuilder {
public:
using Record = std::map<std::string, std::string>;
using Records = std::vector<Record>;
explicit DynamicQueryBuilder(Records data) : data_(std::move(data)) {}
// Добавляем фильтр по конкретному полю
DynamicQueryBuilder& where(std::string field, std::string value) {
filters_.push_back([field, value](const Record& record) {
auto it = record.find(field);
return it != record.end() && it->second == value;
});
return *this;
}
// Строим итоговое представление с применением всех фильтров
auto build() {
auto result = std::views::all(data_);
// Применяем все фильтры последовательно
for (const auto& filter : filters_) {
result = result | std::views::filter(filter);
}
return result;
}
private:
Records data_;
std::vector<std::function<bool(const Record&)>> filters_;
}; |
|
итератора для собственного вектора
помогите пожалуйста сделать итератор для вектора
template <class T>
class myvector
{
private:
... Почему не компилируются вызовы алгоритмов при использовании собственного итератора?
Есть класс итератор. Автономно, со своим вектором он работает прекрасно. В алгоритмах в чем-то... Запись в собственного класса бинарный файл собственного
есть Свой тип данных дробь. Надо реализовать запись и загрузку в\из бинарного файла.
#ifndef... Степенной метод нахождения наибольшего по модулю собственного значения и соответствующего ему собственного вектора
Привет всем. Есть код программы, но почему то он не работает, подскажите в чем дело, может ввожу... Как удалить элементы из map без итераторов?
#include <map>
#include <string>
int main() {
std::map <int, int> myMap;
}
Добавляю в... Создание итератора для дерева общего вида
Возникла такая проблема: надо сделать итератор для дерева общего вида. Я не знаю, как его лучше... Создание структуры итератора для работы с файлом
Всем здравствуйте! Пытаюсь создать итератор, чтоб выводить бинарные данные с файла. По моей идее,... nullptr для итераторов
Присваивание итератору происходит только при некоторых условиях. Как мне определить итератор... Как добавить в QtCreator подсветку / подсказку итераторов auto?
class MyClass
{
public:
MyClass();
int x;
};
QVector<MyClass> data;
for(auto& it :... Как с использованием итераторов в массиве чисел найти количество чисел, меньших за введенное?
Как при помощи итераторов в массиве чисел найти количество чисел, меньших за введенное? Как сделать указатель на предыдущий элемент в массиве без итераторов?
тип MyData хранит в себе матрицу. myarray хранит в себе указатели на матрицы
пробую сделать... Создание итератора map сдвинутого на n
Доброго времени суток :)
Допустим есть функция которая вернет константную ссылку на элемент.
...
|
