此打印代码如何工作？

Question

I found this code somewhere. It prints "abcd" to the screen but in a weird way. I would like someone to tell me how it works:

#include <iostream>
#include <sstream>

class X
{
    typedef std::istreambuf_iterator<char> Iter;
    Iter it;
public:
    X(std::streambuf* p) : it(p) { }

    Iter begin()
        { return it; }
    Iter end()
        { return Iter(); }
};

void printbuf(X x, std::ostreambuf_iterator<char> it)
{
    for (auto c : x)
    {
        *it = c;
    }
}

int main()
{
    std::stringbuf buf("abcd", std::ios_base::in | std::ios_base::out);
    printbuf(&buf, std::cout);
}

Answer 1

We have a class X which encapsulates an istreambuf_iterator <char> . This is an iterator type which allows us to treat a stream buffer as an iterator range for standard algorithms.

class X
{
    typedef std::istreambuf_iterator<char> Iter;
    Iter it;
public:

The class is constructible from a pointer to a stream buffer instance.

    X(std::streambuf* p) : it(p) { }

It exposes begin() and end() member functions to allow it to be used with the range-based for loop.

    Iter begin()
        { return it; }
    Iter end()
        { return Iter(); }
};

printbuf() is a function which accepts an instance of our range class X , as well as an ostreambuf_iterator <char> , which—you guessed it—allows us to use an output stream buffer as an output iterator .

void printbuf(X x, std::ostreambuf_iterator<char> it)
{

So we iterate over every character in the input range.

    for (auto c : x)
    {

If you haven't dealt with output iterators before, you can think of them as an object resembling a pointer, to which you write values using dereference and assignment. back_insert_iterator is a commonly used output iterator, for building containers—you usually construct it using back_inserter . But I digress.

We copy each character to the output iterator.

        *it = c;
    }
}

int main()
{

Here we construct a string buffer, which is both an input and output stream buffer. We only use the input capability in this example.

    std::stringbuf buf("abcd", std::ios_base::in | std::ios_base::out);

Now we use an implicitly-constructed X instance to treat the string buffer as an iterator range. Then we copy that range to an output stream buffer iterator—also implicitly constructed—to std::cout .

    printbuf(&buf, std::cout);
}

The effect is that we're looping over each character in the buffer and copying it to standard output.

Answer 2

printbuf(&buf, std::cout);

Passing std::stringbuf* as the first paramter causes an implicit construction of X to match printbuf()

And also for the second parameter, an implicit contruction occurs, an instance of std::ostreambuf_iterator<char> is created from std::cout (std::ostream)

void printbuf(X x, std::ostreambuf_iterator<char> it)
{
    for (auto c : x)
    {
        *it = c;
    }
}

In printbuf, the foreach loop (range based for loop) uses X::begin() and X::end() to loop over all characters in that wrapped std::stringbuf and writes them to std::cout via the std::ostreambuf_iterator ( it )