C++标准模板（STL）- 迭代器库 - 流迭代器- 写入 std::basic_ostream 的输出迭代器（一）

迭代器库-流迭代器

迭代器库提供了五种迭代器的定义，同时还提供了迭代器特征、适配器及相关的工具函数。

迭代器分类

迭代器共有五 (C++17 前)六 (C++17 起)种：遗留输入迭代器 (LegacyInputIterator) 、遗留输出迭代器 (LegacyOutputIterator) 、遗留向前迭代器 (LegacyForwardIterator) 、遗留双向迭代器 (LegacyBidirectionalIterator) 、遗留随机访问迭代器 (LegacyRandomAccessIterator) ，及 遗留连续迭代器 (LegacyContiguousIterator) (C++17 起)。

迭代器的分类的依据并不是迭代器的类型，而是迭代器所支持的操作。换句话说，某个类型只要支持相应的操作，就可以作为迭代器使用。例如，完整对象类型指针支持所有遗留随机访问迭代器 (LegacyRandomAccessIterator) 要求的操作，于是任何需要遗留随机访问迭代器 (LegacyRandomAccessIterator) 的地方都可以使用指针。

迭代器的所有类别（除了遗留输出迭代器 (LegacyOutputIterator) 和遗留连续迭代器 (LegacyContiguousIterator) ）能组织到层级中，其中更强力的迭代器类别（如遗留随机访问迭代器 (LegacyRandomAccessIterator) ）支持较不强力的类别（例如遗留输入迭代器 (LegacyInputIterator) ）的所有操作。若迭代器落入这些类别之一且亦满足遗留输出迭代器 (LegacyOutputIterator) 的要求，则称之为可变 迭代器并且支持输入还有输出。称非可变迭代器为常迭代器。

 写入 std::basic_ostream 的输出迭代器

std::ostream_iterator

template< class T,           class CharT = char,           class Traits = std::char_traits<CharT> > class ostream_iterator : public std::iterator<std::output_iterator_tag,                                               void, void, void, void>		(C++17 前)
template< class T,           class CharT = char,           class Traits = std::char_traits<CharT>> class ostream_iterator;		(C++17 起)

std::ostream_iterator 是单趟遗留输出迭代器 (LegacyOutputIterator) ，用 operator<< 写入相继 T 类型对象到为之创建迭代器的 std::basic_ostream 对象。每次写操作后写入可选的分隔字符串。写操作在赋值给迭代器时（无论是否解引用）进行。自增 std::ostream_iterator 是无操作。

典型实现中， std::ostream_iterator 仅有的数据成员是指向关联 std::basic_ostream 的指针和指向分隔字符串首字符的指针。

写入字符时， std::ostreambuf_iterator 更有效率，因为它避免对每个字符构造并析构一次 sentry 对象的开销。

成员类型

成员类型	定义
iterator_category	std::output_iterator_tag
value_type	void
difference_type	void
pointer	void
reference	void
char_type	CharT
traits_type	Traits
ostream_type	std::basic_ostream<CharT, Traits>

要求通过从 std::iterator<std::output_iterator_tag, void, void, void, void> 继承获得成员类型 iterator_category 、 value_type 、 difference_type 、 pointer 及 reference 。

(C++17 前)

成员函数

(构造函数)	构造新的 ostream_iterator (公开成员函数)
(析构函数)	析构 ostream_iterator (公开成员函数)
operator=	写对象到关联的输出序列 (公开成员函数)
operator*	无操作 (公开成员函数)
operator++operator++(int)	无操作 (公开成员函数)

构造新的 ostream_iterator

std::ostream_iterator<T,CharT,Traits>::ostream_iterator

ostream_iterator(ostream_type& stream, const CharT* delim)	(1)
ostream_iterator(ostream_type& stream)	(2)

1) 以 stream 为关联流并以 delim 为分隔符构造迭代器。

2) 以 stream 为关联流并以空指针为分隔符构造迭代器。

参数

stream	-	此迭代器所访问的输出流
delim	-	在每次输出后插入流的空终止字符串

析构 ostream_iterator

std::ostream_iterator<T,CharT,Traits>::~ostream_iterator

~ostream_iterator()

销毁迭代器。不影响关联的输出流。

调用示例

#include <iostream>
#include <sstream>
#include <iterator>
#include <numeric>
#include <algorithm>

struct Cell
{
    int x;
    int y;

    Cell() = default;
    Cell(int a, int b): x(a), y(b) {}

    Cell(const Cell &cell)
    {
        x = cell.x;
        y = cell.y;
    }

    Cell(Cell &cell)
    {
        x = cell.x;
        y = cell.y;
        cell.x = 0;
        cell.y = 0;
    }

    Cell &operator +=(const Cell &cell)
    {
        x += cell.x;
        y += cell.y;
        return *this;
    }

    Cell &operator +(const Cell &cell)
    {
        x += cell.x;
        y += cell.y;
        return *this;
    }

    Cell &operator *(const Cell &cell)
    {
        x *= cell.x;
        y *= cell.y;
        return *this;
    }

    Cell &operator ++()
    {
        x += 1;
        y += 1;
        return *this;
    }

    bool operator <(const Cell &cell) const
    {
        if (x == cell.x)
        {
            return y < cell.y;
        }
        else
        {
            return x < cell.x;
        }
    }

    bool operator ==(const Cell &cell) const
    {
        return x == cell.x && y == cell.y;
    }
};

std::ostream &operator<<(std::ostream &os, const Cell &cell)
{
    os << "{" << cell.x << "," << cell.y << "}";
    return os;
}

std::istream &operator>>(std::istream &is, Cell &cell)
{
    is >> cell.x;
    is >> cell.y;
    return is;
}

// 定义一个简单的迭代器适配器
template<typename _Iterator>
class move_iterator : public std::move_iterator<_Iterator>
{
public:
    // 使用基类的构造函数
    using std::move_iterator<_Iterator>::move_iterator;

    // 可以在此添加其他成员函数，如有需要
};

template< class BDIter >
void alg(BDIter, BDIter, std::input_iterator_tag)
{
    //遗留输入迭代器
    std::cout << "alg() called for input iterator" << std::endl;
}

template< class BDIter >
void alg(BDIter, BDIter, std::output_iterator_tag)
{
    //遗留输出迭代器
    std::cout << "alg() called for output iterator" << std::endl;
}

template< class BDIter >
void alg(BDIter, BDIter, std::forward_iterator_tag)
{
    //遗留向前迭代器
    std::cout << "alg() called for forward iterator" << std::endl;
}

template< class BDIter >
void alg(BDIter, BDIter, std::bidirectional_iterator_tag)
{
    //遗留双向迭代器
    std::cout << "alg() called for bidirectional iterator" << std::endl;
}

template <class RAIter>
void alg(RAIter, RAIter, std::random_access_iterator_tag)
{
    //遗留随机访问迭代器
    std::cout << "alg() called for random-access iterator" << std::endl;
}

template< class Iter >
void alg(Iter first, Iter last)
{
    alg(first, last,
        typename std::iterator_traits<Iter>::iterator_category());
}

int main()
{
    std::istringstream istringstream("1 2 3 4 5 6 7 8 9 10");
    std::cout << "partial_sum Cell: ";
    std::partial_sum(std::istream_iterator<Cell>(istringstream),
                     std::istream_iterator<Cell>(),
                     std::ostream_iterator<Cell>(std::cout, " "));
    std::cout << std::endl;

    std::istringstream str2("1 2 3 4 5 6 7 8 9 10");
    auto function = [](const Cell & cell)
    {
        Cell cellt = cell;
        cellt += cell;
        return cellt;
    };

    std::ostream_iterator<Cell> ostream_iterator1(std::cout, ", ");
    std::fill_n(ostream_iterator1, 5, function(Cell{101, 101}));
    std::cout << std::endl;

    std::ostream_iterator<Cell> ostream_iterator2(std::cout);
    *ostream_iterator2++ = Cell{103, 103};
    std::cout << std::endl;

    alg(ostream_iterator2, ostream_iterator2);

    return 0;
}

输出

partial_sum Cell: {1,2} {4,6} {9,12} {16,20} {25,30}
{202,202}, {202,202}, {202,202}, {202,202}, {202,202},
{103,103}
alg() called for output iterator