Simple C++20 input and output iterators

Sometimes I find myself rewriting a snippet often enough that I realize I should just blog it; this is one of those times.

Here’s a simple way to type-erase arbitrary sources and sinks into C++20 input iterators and output iterators. Notice how short these implementations are, as of C++20. In particular, we no longer need most of the “Big Five” iterator_traits typedefs (unless we care about compatibility with -std=c++17): C++20’s iterator_traits is smarter than C++17’s at inferring the missing pieces.

Output iterator

Godbolt.

template<class T>
class Sinkerator {
    struct Proxy {
        const Sinkerator *self_;
        void operator=(std::convertible_to<T> auto&& u) const {
            self_->f_(decltype(u)(u));
        }
    };
public:
    using difference_type = int;
    explicit Sinkerator(std::function<void(T)> f) : f_(std::move(f)) {}
    Proxy operator*() const { return Proxy{this}; }
    Sinkerator& operator++() { return *this; }
    Sinkerator& operator++(int) { return *this; }
private:
    std::function<void(T)> f_;
};

static_assert(std::output_iterator<Sinkerator<int>, short>);
static_assert(!std::output_iterator<Sinkerator<int>, int*>);

Below, it1 and it2 have distinct types, but jt1 and jt2 have the same type, Sinkerator<int>.

auto it1 = std::ostream_iterator<int>(std::cout);
auto it2 = std::back_inserter(v);

auto jt1 = Sinkerator<int>([](int i) { std::cout << i; });
auto jt2 = Sinkerator<int>([&](int i) { v.push_back(i); });

Unidiomatic input iterator

Here’s our first attempt (Godbolt); this does work, but has some caveats discussed below.

template<class T>
class Sourcerator {
public:
    using value_type = std::remove_cvref_t<T>;
    using difference_type = int;
    explicit Sourcerator(std::function<T()> f) : f_(std::move(f)) {}
    T operator*() const { return f_(); }
    Sourcerator& operator++() { return *this; }
    Sourcerator& operator++(int) { return *this; }
    bool operator==(const Sourcerator&) const; // unused
private:
    std::function<T()> f_;
};

static_assert(std::input_iterator<Sourcerator<int>>);
static_assert(std::is_same_v<std::iterator_traits<Sourcerator<int>>::iterator_category, std::input_iterator_tag>);

Below, it1 and it2 have distinct types, but jt1 and jt2 have the same type, Sourcerator<int>.

auto it1 = std::istream_iterator<int>(std::cin);
auto it2 = std::views::iota(0).begin();

auto jt1 = Sourcerator<int>([](){ int i; std::cin >> i; return i; });
auto jt2 = Sourcerator<int>([i=0]() mutable { return i++; });

But input iterators are messier than output iterators: this Sourcerator type has no way to signal “end of input.” Most use-cases will need that. Also, evaluating *it; *it; *it; over and over consumes data from the source; technically, that violates the semantic requirements of the std::input_iterator concept, and it subtly differs from the behavior of std::istream_iterator and std::views::iota.

Idiomatic input iterator

A more idiomatic (if less performant) version goes like this (Godbolt). C++20’s iterator_traits assumes that any default-constructible iterator is at least a forward iterator, so in this version (because of its default constructor) we must hard-code its iterator_category to input_iterator_tag.

template<class T>
class Sourcerator {
public:
    using value_type = T;
    using difference_type = int;
    using iterator_category = std::input_iterator_tag;
    explicit Sourcerator() = default;
    explicit Sourcerator(std::function<std::optional<T>()> f) : f_(std::move(f)), t_(f_()) {}
    const T& operator*() const { return *t_; }
    Sourcerator& operator++() { t_ = f_(); return *this; }
    Sourcerator operator++(int) { auto copy = *this; ++*this; return copy; }
    bool operator==(const Sourcerator& rhs) const { return !t_.has_value() && !rhs.t_.has_value(); }
private:
    std::function<std::optional<T>()> f_;
    std::optional<T> t_;
};

This one lets you, for example, pull all the data out of a priority_queue (and stop when there’s no more data to pull).

auto pq = std::priority_queue<int>({}, {2,5,1,4,3});
auto in = Sourcerator<int>([&]() {
    std::optional<int> result;
    if (!pq.empty()) {
        result = pq.top();
        pq.pop();
    }
    return result;
});
std::copy(in, Sourcerator<int>(), a);
assert(pq.empty());
assert(std::ranges::equal(a, std::initializer_list<int>{5,4,3,2,1}));

You might ask why the first line of that example snippet couldn’t be

std::priority_queue<int> pq = {2,5,1,4,3};

or why the last line couldn’t be

assert(std::ranges::equal(a, {5,4,3,2,1});

I’ll tell you: I don’t know.

Output iterator

Unidiomatic input iterator

Idiomatic input iterator

Recommend

Input and Output in Hoon

Python Tutorial - User Input and Output

Standard Input, Output, and Error in Java

Syncing input and output devices on multihead machines

In Input We Don't Trust... and in JavaScript, don't trust output either ;)

Python - Input and Output

Reading Input and Writing Output in Python

C++ from the beginning, input and output

A neat technique for custom output iterators

Google Colab notebook - input and output, OpenAI TTS API

About Joyk