blocks|key|506078|text|如果你在一个流上设置了badbit，它不会输出任何东西：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|506079|#include+<iostream>

int+main()+{
++++std::cout+<<+"a\n";

++++std::cout.setstate(std::ios_base::badbit);
++++std::cout+<<+"b\n";

++++std::cout.clear();
++++std::cout+<<+"c\n";
}|code-block|syntax|javascript|506080|输出：|506081|a
c|506082|entityMap^0|B|6|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

If you set <code>badbit</code> on a stream it won't output anything:

<pre><code>#include &lt;iostream&gt;

int main() {
 std::cout &lt;&lt; "a\n";

 std::cout.setstate(std::ios_base::badbit);
 std::cout &lt;&lt; "b\n";

 std::cout.clear();
 std::cout &lt;&lt; "c\n";
}
</code></pre>

Outputs:

<pre><code>a
c
</code></pre>

blocks|key|722270|text|最简单的解决方案就是使用一个未打开的std::ofstream。这将导致流中的错误状态，但大多数输出器不会检查这一点；通常的习惯用法是将检查留到结束符之后(这将把它放在您编写的代码中，您知道流应该是无效的)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|722271|否则，实现起来非常简单:只需创建一个包含小缓冲区的streambuf，并在overflow中设置它(总是返回成功)。请注意，这将比未打开的文件慢；各种>>操作符仍将执行所有转换(如果流有错误状态，则不会执行此操作)。|722272|编辑：|722273|class+NulStreambuf+:+public+std::streambuf
{
++++char++++++++++++++++dummyBuffer[+64+];
protected:
++++virtual+int+++++++++overflow(+int+c+)+
++++{
++++++++setp(+dummyBuffer,+dummyBuffer+%2B+sizeof(+dummyBuffer+)+);
++++++++return+(c+==+traits_type::eof())+?+'\0'+:+c;
++++}
};|code-block|syntax|javascript|722274|通常也会提供一个从istream或ostream派生的方便类，该类将包含它所使用的缓冲区的一个实例。大致是这样的：|722275|class+NulOStream+:+private+NulStreambuf,+public+std::ostream
{
public:
++++NulOStream()+:+std::ostream(+this+)+{}
++++NulStreambuf*+rdbuf()+const+{+return+this;+}
};|722276|或者，您可以只使用std::ostream，将streambuf的地址传递给它。|722277|entityMap^0|I|D|0|P|9|11|8|23|2|0|0|0|9|7|H|7|0|0|9|C|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|16|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|17|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|18|8|@$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|L|7|1D|8|@]|D|@]|E|$M|N]]|$1|S|3|T|5|6|7|1E|8|@$9|1F|A|1G|B|C]]|D|@]|E|$]]|$1|U|3|-4|5|6|7|1H|8|@]|D|@]|E|$]]]|V|$]]

The simplest solution is just to use an unopened <code>std::ofstream</code>. This
will result in an error state in the stream, but most outputters won't
check this; the usual idiom is to leave the check to the end, after the
close (which would put it in code you wrote, where you know that the
stream should be invalid). 

Otherwise, it's pretty straight forward to implement: just create a
<code>streambuf</code> which contains a small buffer, and sets it up in <code>overflow</code>
(always returning success). Note that this will be slower than the
unopened file, however; the various <code>&gt;&gt;</code> operators will still to all of
the conversion (which they don't do if the stream has an error state). 

EDIT:

<pre><code>class NulStreambuf : public std::streambuf
{
 char dummyBuffer[ 64 ];
protected:
 virtual int overflow( int c ) 
 {
 setp( dummyBuffer, dummyBuffer + sizeof( dummyBuffer ) );
 return (c == traits_type::eof()) ? '\0' : c;
 }
};
</code></pre>

It's usual to provide a convenience class derived from <code>istream</code>
or <code>ostream</code> as well, which will contain an instance of this
buffer which it uses. Something along the lines of:

<pre><code>class NulOStream : private NulStreambuf, public std::ostream
{
public:
 NulOStream() : std::ostream( this ) {}
 NulStreambuf* rdbuf() const { return this; }
};
</code></pre>

Or you can just use an <code>std::ostream</code>, passing the address of
the streambuf to it.

blocks|key|722340|text|如果您有boost，那么在boost/iostream/device/null.hpp中有一个null+ostream+&+istream实现。它的要点是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|722341|#include+"boost/iostreams/stream.hpp"
#include+"boost/iostreams/device/null.hpp"
...
boost::iostreams::stream<+boost::iostreams::null_sink+>+nullOstream(+(+boost::iostreams::null_sink()+)+);
...|code-block|syntax|javascript|722342|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you have boost, then there's a null ostream &amp; istream implementation available in boost/iostreams/device/null.hpp . The gist of it:

<pre><code>#include "boost/iostreams/stream.hpp"
#include "boost/iostreams/device/null.hpp"
...
boost::iostreams::stream&lt; boost::iostreams::null_sink &gt; nullOstream( ( boost::iostreams::null_sink() ) );
...
</code></pre>

blocks|key|722387|text|对我来说，最简单的方法是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|722388|#include+<fstream>

std::ostream*+out+=+&std::cout;

std::ostream*+nullstream()+{
++++static+std::ofstream+os;
++++if+(!os.is_open())
++++++++os.open("/dev/null",+std::ofstream::out+%7C+std::ofstream::app);
++++return+&os;
}

int+main()+{
++++*out+<<+"Normal+output\n";

++++out+=+nullstream();
++++*out+<<+"Will+not+visible\n";

++++out+=+&std::cout;
++++*out+<<+"Back+again\n";

++++return+0;
}|code-block|syntax|javascript|722389|或者如上所述，在'nullstream‘函数中使用'badbit’标志而不是'/dev/null‘。|722390|std::ostream*+nullstream()+{
++++static+std::ofstream+os;
++++static+bool+flag_set+=+false;
++++if+(!flag_set)+{
++++++++os.setstate(std::ios_base::badbit);
++++++++flag_set+=+true;
++++}
++++return+&os;
}|722391|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

As for me the simplest way would be:

<pre><code>#include &lt;fstream&gt;

std::ostream* out = &amp;std::cout;

std::ostream* nullstream() {
 static std::ofstream os;
 if (!os.is_open())
 os.open("/dev/null", std::ofstream::out | std::ofstream::app);
 return &amp;os;
}

int main() {
 *out &lt;&lt; "Normal output\n";

 out = nullstream();
 *out &lt;&lt; "Will not visible\n";

 out = &amp;std::cout;
 *out &lt;&lt; "Back again\n";

 return 0;
}
</code></pre>

Or use 'badbit' flag instead of '/dev/null' in 'nullstream' function as described above.

<pre><code>std::ostream* nullstream() {
 static std::ofstream os;
 static bool flag_set = false;
 if (!flag_set) {
 os.setstate(std::ios_base::badbit);
 flag_set = true;
 }
 return &amp;os;
}
</code></pre>

blocks|key|506339|text|希望此解决方案可以在不使用boost的情况下克服性能问题：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|506340|#include+<ostream>

class+dev0_buffer+:+public+std::streambuf
{
+++//called+usually+for+n-characters
+++std::streamsize+xsputn+(const+char*+s,+std::streamsize+n)+override+{+return+n;+}

+++//may+not+required+due+it's+not+called+anymore
+++int+overflow+(int+c)++override+{+return+c;+}+
}+nirwana;

class+dev0_stream+:+public+std::ostream
{
+++public:
++++dev0_stream():+std::ostream(&nirwana){}
};|code-block|syntax|javascript|506341|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

May this solution overcomes the performance issue without using boost:

<pre><code>#include &lt;ostream&gt;

class dev0_buffer : public std::streambuf
{
 //called usually for n-characters
 std::streamsize xsputn (const char* s, std::streamsize n) override { return n; }

 //may not required due it's not called anymore
 int overflow (int c) override { return c; } 
} nirwana;

class dev0_stream : public std::ostream
{
 public:
 dev0_stream(): std::ostream(&amp;nirwana){}
};
</code></pre>

blocks|key|506363|text|struct+NullStream+//+only+subclass+std::stream+if+you+must
{
++++template<typename+T>
++++NullStream&+operator<<(T+const&)+{+return+*this;+}
};

NullStream+TheNullStream;+//+There's+your+global+instance|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|506364|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre class="lang-cpp prettyprint-override"><code>struct NullStream // only subclass std::stream if you must
{
 template&lt;typename T&gt;
 NullStream&amp; operator&lt;&lt;(T const&amp;) { return *this; }
};

NullStream TheNullStream; // There's your global instance
</code></pre>

blocks|key|506442|text|根据@user5406764的回答，可以通过重载全局<<操作符来跳过任何实际操作。解决方案应该是跨平台的，并且是最快的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|506443|#include+<iostream>

class+NullStream+:+public+std::ostream+{
public:
++NullStream()+:+std::ostream(nullptr)+{}
++NullStream(const+NullStream+&)+:+std::ostream(nullptr)+{}
};

template+<class+T>
const+NullStream+&operator<<(NullStream+&&os,+const+T+&value)+{+
++return+os;
}

int+main()+{
++auto+null+=+NullStream();
++std::cerr+<<+"a"+<<+std::endl;
++null+<<+"b"+<<+std::endl;
++std::cerr+<<+"c"+<<+std::endl;
}|code-block|syntax|javascript|506444|输出：|506445|a
c|506446|entityMap^0|Q|2|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

Following the @user5406764's answer, it is possible to skip any actual operations by overloading the global <code>&lt;&lt;</code> operator. The solution should be cross-platform and the fastest one.

<pre><code>#include &lt;iostream&gt;

class NullStream : public std::ostream {
public:
 NullStream() : std::ostream(nullptr) {}
 NullStream(const NullStream &amp;) : std::ostream(nullptr) {}
};

template &lt;class T&gt;
const NullStream &amp;operator&lt;&lt;(NullStream &amp;&amp;os, const T &amp;value) { 
 return os;
}

int main() {
 auto null = NullStream();
 std::cerr &lt;&lt; "a" &lt;&lt; std::endl;
 null &lt;&lt; "b" &lt;&lt; std::endl;
 std::cerr &lt;&lt; "c" &lt;&lt; std::endl;
}
</code></pre>

Output:

<pre><code>a
c
</code></pre>

blocks|key|506509|text|您可以在没有第三方库的情况下完成此操作。只需使用rdbuf将关联的流缓冲区设置为nullptr，即可完成任务|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|506510|std::cout+<<+"Hello,";
std::cout.rdbuf(nullptr);
std::cout+<<+"+world!\n";|code-block|syntax|javascript|506511|在线示例here。|506512|entityMap|0|LINK|mutability|MUTABLE|url|https://en.cppreference.com/w/cpp/io/basic_ios/rdbuf|1|https://onlinegdb.com/ByuhrnfnI^0|O|5|14|7|O|5|0|0|0|4|4|1|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@$9|11|A|12|1|13]]|E|$]]|$1|F|3|G|5|H|7|14|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|15|8|@]|D|@$9|16|A|17|1|18]]|E|$]]|$1|M|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]|U|$5|P|Q|R|E|$S|V]]]]

You can do it without third-party libraries. Just set the associated stream buffer to <code>nullptr</code> using <a href="https://en.cppreference.com/w/cpp/io/basic_ios/rdbuf" rel="nofollow noreferrer"><code>rdbuf</code></a> and your job is done

<pre><code>std::cout &lt;&lt; "Hello,";
std::cout.rdbuf(nullptr);
std::cout &lt;&lt; " world!\n";
</code></pre>

Online example <a href="https://onlinegdb.com/ByuhrnfnI" rel="nofollow noreferrer">here</a>.

I'm looking for a <code>std::ostream</code> implementation that acts like <code>/dev/null</code>. It would just ignore anything that is streamed to it. Does such a thing exist in the standard libraries or Boost? Or do I have to roll my own?

Is there a null std::ostream implementation in C++ or libraries?

我正在寻找一个行为类似于/dev/null的std::ostream实现。它会忽略任何流到它的内容。在标准库或Boost中是否存在这样的东西？或者我必须自己滚？

问在C++或库中是否有空的std::ostream实现？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C++或库中是否有空的std::ostream实现？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C++或库中是否有空的std::ostream实现？
EN