丢弃接受输出迭代器的函数的输出

Question

假设 C++ 中有一个模板函数，它执行一些有用的工作，但也通过输出迭代器输出一系列值。 现在假设值的序列有时很有趣，但有时没有用。 STL 中是否有一个现成的迭代器类可以实例化并传递给函数，并且会忽略函数尝试分配给它的任何值？ 换句话说，将所有数据发送到/dev/null？

Answer 1

STL没有提供这样的迭代器。 但您可以自己编写代码（测试该代码）：

struct null_output_iterator : 
    std::iterator< std::output_iterator_tag,
                   null_output_iterator > {
    /* no-op assignment */
    template<typename T>
    void operator=(T const&) { }

    null_output_iterator & operator++() { 
        return *this; 
    }

    null_output_iterator operator++(int) { 
        return *this;
    }

    null_output_iterator & operator*() { return *this; }
};

通过使用自身作为 operator* 的结果，它不需要任何数据。 *it = x; 的结果未在输出迭代器要求中使用，因此我们可以为其指定返回类型 void。

---

编辑：让我们来看看这个operator*是如何工作的。 该标准在 24.1.2/1 中提到了在这两种情况下输出迭代器的要求：

*it = t;
*it++ = t;

不使用这些表达式的结果。 这就是它的工作原理：

null_output_iterator it;
*it; // returns a null_output_iterator& per definition of the `operator*`.
*it = some_value; // returns void per definition of the templated `operator=`. 

现在我们不需要在 operator* 中返回任何数据：我们只需使用迭代器本身。 请注意，模板化运算符= 不会覆盖内置复制赋值运算符。 还是提供了。

Answer 2

你有可用的Boost吗？ 如果是这样，您可以使用 function_output_iterator 包装一个空函数。

但这并不理想。 无论您使用什么迭代器，仍然需要创建 value_type 的实例以在操作符 * 中返回，即使它随后将其丢弃。

Answer 3

写一篇并不难。

template<typename T>
class NullOutputIterator
{
public:
    NullOutputIterator() {}
    NullOutputIterator& operator++() { return *this; }
    NullOutputIterator& operator++(int) { return *this; }
    T& operator*() { return m; }
    T* operator->() { return &m; }
private:
    T m;
};

我还没有测试过这个，可能缺少一些重要的东西，但我认为这就是这个想法。

Answer 4

我基于 std::back_insert_iterator，但没有容器：

#include <iterator>

template<typename T>
class NullOutputIter
    : public std::iterator<std::output_iterator_tag,void,void,void,void>
{
public:
    NullOutputIter &operator=(const T &) { return *this; }
    NullOutputIter &operator*() { return *this; }
    NullOutputIter &operator++() { return *this; }
    NullOutputIter operator++(int) { return *this; }
};

这与 Johannes 的答案类似，但没有接受任何内容的模板 operator= 。 我喜欢强打字； 我希望 *it = false_type_thing 成为编译时错误。 此外，它还使用 void 作为 std::iterator 的各种模板参数，就像标准库中的输出迭代器一样。

这也类似于 Mark 的解决方案，但是 (a) 它正确地继承自 std::iterator 并且 (b) 它没有不需要的内部状态变量。

Answer 5

更新答案（2022）

对于 C++17，std::iterator 已弃用。 如果你想避免警告，你必须在公共接口中声明类型：

  ///
  /// @brief Allows to discard the output of functions that requires an output iterator
  ///
  template<typename T>
  struct null_output_iterator
  {
    using iterator_category = std::forward_iterator_tag;
    using value_type = T;
    using difference_type = T;
    using pointer = T*;
    using reference = T&;
    ///
    /// @brief No-op assignment
    ///
    void operator=(T const&) {}
    ///
    /// @brief Can be pre-incremented
    ///
    null_output_iterator & operator++()
    {
      return *this;
    }
    ///
    /// @brief Can be post-incremented
    ///
    null_output_iterator operator++(int)
    {
      return *this;
    }
    ///
    /// @brief Can be dereferenced
    ///
    null_output_iterator & operator*()
    {
      return *this;
    }
  };