Clearly, streams can&#39;t be copied. It should be possible to move streams. According to 27.9.1.11 [ofstream.cons] paragraph 4 it is possible to move construct an `std::ofstream` (the same is true for `std::ifstream`, `std::fstream`, and the `std::*stringstream` variants). For example:

    #include &lt;iostream&gt;
    #include &lt;fstream&gt;
    #include &lt;string&gt;
    
    std::ofstream makeStream(std::string const&amp; name) {
        return std::ofstream(name);
    }
    
    int main()
    {
        std::ofstream out{ makeStream(&quot;example.log&quot;) };
    }

Trying to move an `std::ostream`, e.g., to have a factory function creating an `std::ofstream`, an `std::ostringstream`, or some other stream according to a URN passed as argument doesn&#39;t work. `std::ostream` (well, the class template `std::basic_ostream` really) has a `protected` move constructor according to 27.7.3.1 [ostream].

Why can&#39;t `std::ostream` be moved itself?

Why can&#39;t std::ostream be moved?

I&#39;ve always wondered why the C++ Standard library has instantiated basic_[io]stream and all its variants using the &lt;code&gt;char&lt;/code&gt; type instead of the &lt;code&gt;unsigned char&lt;/code&gt; type. &lt;code&gt;char&lt;/code&gt; means (depending on whether it is signed or not) you can have overflow and underflow for operations like get(), which will lead to implementation-defined value of the variables involved. Another example is when you want to output a byte, unformatted, to an ostream using its `put` function.

Any ideas?

----------
**Note**: I&#39;m still not really convinced. So if you know the definitive answer, you can still post it indeed.

Why do C++ streams use char instead of unsigned char?

how do I bind a `std::ostream` to either `std::cout` or to an `std::ofstream` object, depending on a certain program condition? Although this invalid for many reasons, I would like to achieve something that is semantically equivalent to the following:

    std::ostream out = condition ? &amp;std::cout : std::ofstream(filename);

I&#39;ve seen some examples that are not exception-safe, such as one from [http://www2.roguewave.com/support/docs/sourcepro/edition9/html/stdlibug/34-2.html][1]:

    int main(int argc, char *argv[])
    {
      std::ostream* fp;                                           //1
      if (argc &gt; 1)
         fp = new std::ofstream(argv[1]);                         //2
      else
         fp = &amp;std::cout                                          //3

      *fp &lt;&lt; &quot;Hello world!&quot; &lt;&lt; std::endl;                         //4
      if (fp!=&amp;std::cout) 
         delete fp;
    }


Does anyone know a better, exception-safe solution?


  [1]: http://www2.roguewave.com/support/docs/sourcepro/edition9/html/stdlibug/34-2.html

Obtain a std::ostream either from std::cout or std::ofstream(file)

A colleague just told me that this code:

    std::ifstream stream(filename.c_str());
    if (!stream)
    {
    	throw std::runtime_error(&quot;..&quot;);
    }

would be wrong. He said `ifstream` evaluates to 0 if opening is successful. My code works, but I wanted to find the documentation but didn&#39;t see where it says how to check if opening was successful. Can you point me to it?

ifstream: check if opened successfully

I was listening to a [google talk by Andrei Alexandrescu on the D programming][1] language when he threw out a one liner about the &quot;endl&quot; fiasco. I just thought endl was the preferred way to signify the end of a line and flush the buffer for a stream. Why is it considered a fiasco? Should I not be using it in my code?


  [1]: http://www.youtube.com/watch?v=RlVpPstLPEc

What is the C++ iostream endl fiasco?

I&#39;m looking for a library which operates similar to iostreams, in that it performs conversions, and allows writing to memory buffers, files, and the console. However, I&#39;d like something type safe, as iostream is. Are there any serious libraries which do this?

Being able to specify the output encoding for things would be a plus.

Note that I&#39;m not interested in libraries which simply front iostreams because they just add *more* complexity to what iostreams is doing, e.g. `boost::format`.

PreEmptive comment response: I don&#39;t want to use cstdio because using that system it&#39;s impossible to have code be output location agnostic. That is, you have to call one function for sending things to buffers, and you have to call another function to send things to files, and another for the console, etc.

EDIT2: In response to the flurry of comments below: I&#39;m fed up with both iostreams and cstdio. Here are more specific reasons. I tried to keep my &quot;rant&quot; out of this question, but people keep asking my if I&#39;m off my rocker, so here&#39;s my rationale.

### cstdio

* Can&#39;t handle Unicode characters correctly
* Can&#39;t write into something like a string without doing manual buffer management
* Often requires support of nonstandard extensions (e.g. `vsnprintf`) in order to be usable (EDIT: Okay, C99&#39;s standard library being in C++11 adds most/all of these now)
* Can&#39;t change the location of output without changing the original code (nonstandard extensions e.g. in glibc allow you to treat a file pointer as a buffer, which kind of does this... but it&#39;s still just that, a nonstandard extension)
* Makes security &quot;fun&quot; (to the point where entire chapters are dedicated in security docs explaining issues, e.g. with &quot;printf&quot;&#39;s format strings and such)
* Not type safe

### iostreams

* Slow
* Entirely too complicated to a client. If you use only what comes with the standard library it&#39;s great, but attempting to extend things is next to impossible. I read the entire &quot;Standard C++ IOStreams and Locales&quot; book -- the only book seemingly available on the topic -- *twice* -- and I still don&#39;t know what&#39;s going on.

I love iostreams in concept, even the use of `operator&lt;&lt;` which some people seem to not like, but it seems entirely too over engineered to me. Someone should not have to spend countless hours reading books in order to be a simple client of your library. Sure, if you&#39;re adding a new output source or something like that I could understand, but.... clients should be shielded from that complexity. (Isn&#39;t that what a library&#39;s for?)

This is about the only thing that&#39;s painful in C++ that &quot;just works&quot; in other programming languages, that I see no reason to be complicated.

What serious alternatives exist for the IOStream library? (besides cstdio)

I am using the GCC built-in type `__int128` for a few things in my C++ program, nothing really significant, at least not enough to justify to use BigInt library only for that and, yet, enough to prevent to remove it totally.

My problem comes when I run into the printing parts my classes, here is a minimal example:

    #include &lt;iostream&gt;

    int main()
    {
      __int128 t = 1234567890;

      std::cout &lt;&lt; t &lt;&lt; std::endl;

      return t;
    }

Commenting out the `std::cout` line will make this code to compile nicely with `g++`, but having it will cause the following error message:

    int128.c: In function ‘int main()’:
    int128.c:7:13: error: ambiguous overload for ‘operator&lt;&lt;’ (operand types are ‘std::ostream {aka std::basic_ostream&lt;char&gt;}’ and ‘__int128’)
       std::cout &lt;&lt; t &lt;&lt; std::endl;
                 ^
    int128.c:7:13: note: candidates are:
    In file included from /usr/include/c++/4.9/iostream:39:0,
                     from int128.c:1:
    /usr/include/c++/4.9/ostream:108:7: note: std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type&amp; (*)(std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type&amp;)) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;; std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type = std::basic_ostream&lt;char&gt;] &lt;near match&gt;
           operator&lt;&lt;(__ostream_type&amp; (*__pf)(__ostream_type&amp;))
           ^
    /usr/include/c++/4.9/ostream:108:7: note:   no known conversion for argument 1 from ‘__int128’ to ‘std::basic_ostream&lt;char&gt;::__ostream_type&amp; (*)(std::basic_ostream&lt;char&gt;::__ostream_type&amp;) {aka std::basic_ostream&lt;char&gt;&amp; (*)(std::basic_ostream&lt;char&gt;&amp;)}’
    /usr/include/c++/4.9/ostream:117:7: note: std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;::__ios_type&amp; (*)(std::basic_ostream&lt;_CharT, _Traits&gt;::__ios_type&amp;)) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;; std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type = std::basic_ostream&lt;char&gt;; std::basic_ostream&lt;_CharT, _Traits&gt;::__ios_type = std::basic_ios&lt;char&gt;] &lt;near match&gt;
           operator&lt;&lt;(__ios_type&amp; (*__pf)(__ios_type&amp;))
           ^
    /usr/include/c++/4.9/ostream:117:7: note:   no known conversion for argument 1 from ‘__int128’ to ‘std::basic_ostream&lt;char&gt;::__ios_type&amp; (*)(std::basic_ostream&lt;char&gt;::__ios_type&amp;) {aka std::basic_ios&lt;char&gt;&amp; (*)(std::basic_ios&lt;char&gt;&amp;)}’
    /usr/include/c++/4.9/ostream:127:7: note: std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(std::ios_base&amp; (*)(std::ios_base&amp;)) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;; std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type = std::basic_ostream&lt;char&gt;] &lt;near match&gt;
           operator&lt;&lt;(ios_base&amp; (*__pf) (ios_base&amp;))
           ^
    /usr/include/c++/4.9/ostream:127:7: note:   no known conversion for argument 1 from ‘__int128’ to ‘std::ios_base&amp; (*)(std::ios_base&amp;)’
    /usr/include/c++/4.9/ostream:166:7: note: std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(long int) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;; std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type = std::basic_ostream&lt;char&gt;]
           operator&lt;&lt;(long __n)
           ^
    /usr/include/c++/4.9/ostream:170:7: note: std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(long unsigned int) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;; std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type = std::basic_ostream&lt;char&gt;]
           operator&lt;&lt;(unsigned long __n)
           ^
    /usr/include/c++/4.9/ostream:174:7: note: std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(bool) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;; std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type = std::basic_ostream&lt;char&gt;]
           operator&lt;&lt;(bool __n)
           ^
    In file included from /usr/include/c++/4.9/ostream:609:0,
                     from /usr/include/c++/4.9/iostream:39,
                     from int128.c:1:
    /usr/include/c++/4.9/bits/ostream.tcc:91:5: note: std::basic_ostream&lt;_CharT, _Traits&gt;&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(short int) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;]
         basic_ostream&lt;_CharT, _Traits&gt;::
         ^
    In file included from /usr/include/c++/4.9/iostream:39:0,
                     from int128.c:1:
    /usr/include/c++/4.9/ostream:181:7: note: std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(short unsigned int) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;; std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type = std::basic_ostream&lt;char&gt;]
           operator&lt;&lt;(unsigned short __n)
           ^
    In file included from /usr/include/c++/4.9/ostream:609:0,
                     from /usr/include/c++/4.9/iostream:39,
                     from int128.c:1:
    /usr/include/c++/4.9/bits/ostream.tcc:105:5: note: std::basic_ostream&lt;_CharT, _Traits&gt;&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(int) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;]
         basic_ostream&lt;_CharT, _Traits&gt;::
         ^
    In file included from /usr/include/c++/4.9/iostream:39:0,
                     from int128.c:1:
    /usr/include/c++/4.9/ostream:192:7: note: std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(unsigned int) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;; std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type = std::basic_ostream&lt;char&gt;]
           operator&lt;&lt;(unsigned int __n)
           ^
    /usr/include/c++/4.9/ostream:201:7: note: std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(long long int) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;; std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type = std::basic_ostream&lt;char&gt;]
           operator&lt;&lt;(long long __n)
           ^
    /usr/include/c++/4.9/ostream:205:7: note: std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(long long unsigned int) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;; std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type = std::basic_ostream&lt;char&gt;]
           operator&lt;&lt;(unsigned long long __n)
           ^
    /usr/include/c++/4.9/ostream:220:7: note: std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(double) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;; std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type = std::basic_ostream&lt;char&gt;]
           operator&lt;&lt;(double __f)
           ^
    /usr/include/c++/4.9/ostream:224:7: note: std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(float) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;; std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type = std::basic_ostream&lt;char&gt;]
           operator&lt;&lt;(float __f)
           ^
    /usr/include/c++/4.9/ostream:232:7: note: std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(long double) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;; std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type = std::basic_ostream&lt;char&gt;]
           operator&lt;&lt;(long double __f)
           ^
    /usr/include/c++/4.9/ostream:245:7: note: std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(const void*) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;; std::basic_ostream&lt;_CharT, _Traits&gt;::__ostream_type = std::basic_ostream&lt;char&gt;] &lt;near match&gt;
           operator&lt;&lt;(const void* __p)
           ^
    /usr/include/c++/4.9/ostream:245:7: note:   no known conversion for argument 1 from ‘__int128’ to ‘const void*’
    In file included from /usr/include/c++/4.9/ostream:609:0,
                     from /usr/include/c++/4.9/iostream:39,
                     from int128.c:1:
    /usr/include/c++/4.9/bits/ostream.tcc:119:5: note: std::basic_ostream&lt;_CharT, _Traits&gt;&amp; std::basic_ostream&lt;_CharT, _Traits&gt;::operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;::__streambuf_type*) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;; std::basic_ostream&lt;_CharT, _Traits&gt;::__streambuf_type = std::basic_streambuf&lt;char&gt;] &lt;near match&gt;
         basic_ostream&lt;_CharT, _Traits&gt;::
         ^
    /usr/include/c++/4.9/bits/ostream.tcc:119:5: note:   no known conversion for argument 1 from ‘__int128’ to ‘std::basic_ostream&lt;char&gt;::__streambuf_type* {aka std::basic_streambuf&lt;char&gt;*}’
    In file included from /usr/include/c++/4.9/iostream:39:0,
                     from int128.c:1:
    /usr/include/c++/4.9/ostream:493:5: note: std::basic_ostream&lt;char, _Traits&gt;&amp; std::operator&lt;&lt;(std::basic_ostream&lt;char, _Traits&gt;&amp;, unsigned char) [with _Traits = std::char_traits&lt;char&gt;]
         operator&lt;&lt;(basic_ostream&lt;char, _Traits&gt;&amp; __out, unsigned char __c)
         ^
    /usr/include/c++/4.9/ostream:488:5: note: std::basic_ostream&lt;char, _Traits&gt;&amp; std::operator&lt;&lt;(std::basic_ostream&lt;char, _Traits&gt;&amp;, signed char) [with _Traits = std::char_traits&lt;char&gt;]
         operator&lt;&lt;(basic_ostream&lt;char, _Traits&gt;&amp; __out, signed char __c)
         ^
    /usr/include/c++/4.9/ostream:482:5: note: std::basic_ostream&lt;char, _Traits&gt;&amp; std::operator&lt;&lt;(std::basic_ostream&lt;char, _Traits&gt;&amp;, char) [with _Traits = std::char_traits&lt;char&gt;]
         operator&lt;&lt;(basic_ostream&lt;char, _Traits&gt;&amp; __out, char __c)
         ^
    /usr/include/c++/4.9/ostream:476:5: note: std::basic_ostream&lt;_CharT, _Traits&gt;&amp; std::operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp;, char) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;]
         operator&lt;&lt;(basic_ostream&lt;_CharT, _Traits&gt;&amp; __out, char __c)
         ^

Yes, I know, a lot of lines to explain that `__int128` is just not properly handled...

Is there a **simple** way to get `__int128` to be printed by the `iostream` as any other numeric types ?

EDIT: For those who are still confusing C and C++, yes, I read the question: [how to print __uint128_t number using gcc?](https://stackoverflow.com/questions/11656241/how-to-print-uint128-t-number-using-gcc) But, this was for C and not for C++ as I am asking now.

How to print __int128 in g++?

I&#39;m used to the Delphi VCL Framework, where TStreams throw exceptions on errors (e.g file not found, disk full). I&#39;m porting some code to use C++ STL instead, and have been caught out by iostreams NOT throwing exceptions by default, but setting [badbit/failbit flags][1] instead.

Two questions...

 a: Why is this - It seems an odd design decision for a language built with exceptions in it from day one?

 b: How best to avoid this? I could produce shim classes that throw as I would expect, but this feels like reinventing the wheel. Maybe there&#39;s a BOOST library that does this in a saner fashion?


  [1]: http://en.cppreference.com/w/cpp/io/ios_base/iostate

Why are C++ STL iostreams not &quot;exception friendly&quot;?

What does the &quot;c&quot; mean in the `cout`, `cin`, `cerr` and `clog` names?

I would say `char` but I haven&#39;t found anything to confirm it.

What does the &quot;c&quot; mean in cout, cin, cerr and clog?

Is there a way to create an ostream instance which basically doesn&#39;t do anything ?

For example :

    std::ostream dummyStream(...);
    dummyStream &lt;&lt; &quot;Nothing will be printed&quot;;

I could just create an ostringstream, but data will be buffered (and I really don&#39;t want to make anything with them, so it adds a useless overhead).

Any idea ?

**[edit]** Found this [related question](https://stackoverflow.com/questions/8243743/is-there-a-null-stdostream-implementation-in-c-or-libraries) which suits my needs. However, I think it could be useful to have a answer saying how to create a *valid* (no badbit) output stream with standard c++.

Standard no-op output stream

I&#39;m following a college course about operating systems and we&#39;re learning how to convert from binary to hexadecimal, decimal to hexadecimal, etc. and today we just learned how signed/unsigned numbers are stored in memory using the two&#39;s complement (~number + 1).

We have a couple of exercises to do on paper and I would like to be able to verify my answers before submitting my work to the teacher. I wrote a C++ program for the first few exercises but now I&#39;m stuck as to how I could verify my answer with the following problem:

    char a, b;
    
    short c;
    a = -58;
    c = -315;
    
    b = a &gt;&gt; 3;

and we need to show the binary representation *in memory* of `a`, `b` and `c`.

I&#39;ve done it on paper and it gives me the following results (all the binary representations in memory of the numbers after the two&#39;s complement):

&gt; a = 00111010 (it&#39;s a char, so 1 byte)
&gt;
&gt; b = 00001000 (it&#39;s a char, so 1 byte)
&gt;
&gt; c = 11111110 11000101 (it&#39;s a short, so 2 bytes)

Is there a way to verify my answer? Is there a standard way in C++ to show the binary representation in memory of a number, or do I have to code each step myself (calculate the two&#39;s complement and then convert to binary)? I know the latter wouldn&#39;t take so long but I&#39;m curious as to if there is a standard way to do so.

How to print (using cout) a number in binary form?

I am writing a small matrix library in C++ for matrix operations. However my compiler complains, where before it did not. This code was left on a shelf for 6 months and in between I upgraded my computer from debian etch to lenny (g++ (Debian 4.3.2-1.1) 4.3.2
) however I have the same problem on a Ubuntu system with the same g++.

Here is the relevant part of my matrix class:

    namespace Math
    {
    	class Matrix
    	{
    	public:
    
    		[...]
    
    		friend std::ostream&amp; operator&lt;&lt; (std::ostream&amp; stream, const Matrix&amp; matrix);
    	}
    }

And the &quot;implementation&quot;:

    using namespace Math;

    std::ostream&amp; Matrix::operator &lt;&lt;(std::ostream&amp; stream, const Matrix&amp; matrix) {
    
        [...]
    
    }

This is the error given by the compiler:

&gt; matrix.cpp:459: error: &#39;std::ostream&amp;
&gt; Math::Matrix::operator&lt;&lt;(std::ostream&amp;,
&gt; const Math::Matrix&amp;)&#39; must take
&gt; exactly one argument

I&#39;m a bit confused by this error, but then again my C++ has gotten a bit rusty after doing lots of Java those 6 months. :-)


How to properly overload the &lt;&lt; operator for an ostream?

Every time I mention slow performance of C++ standard library iostreams, I get met with a wave of disbelief.  Yet I have profiler results showing large amounts of time spent in iostream library code (full compiler optimizations), and switching from iostreams to OS-specific I/O APIs and custom buffer management does give an order of magnitude improvement.

What extra work is the C++ standard library doing, is it required by the standard, and is it useful in practice?  Or do some compilers provide implementations of iostreams that are competitive with manual buffer management?

Benchmarks
-
To get matters moving, I&#39;ve written a couple of short programs to exercise the iostreams internal buffering:

* putting binary data into an `ostringstream` http://ideone.com/2PPYw
* putting binary data into a `char[]` buffer http://ideone.com/Ni5ct
* putting binary data into a `vector&lt;char&gt;` using `back_inserter` http://ideone.com/Mj2Fi
* **NEW**: `vector&lt;char&gt;` simple iterator http://ideone.com/9iitv
* **NEW**: putting binary data directly into `stringbuf` http://ideone.com/qc9QA
* **NEW**: `vector&lt;char&gt;` simple iterator plus bounds check http://ideone.com/YyrKy

Note that the `ostringstream` and `stringbuf` versions run fewer iterations because they are so much slower.

On ideone, the `ostringstream` is about 3 times slower than `std:copy` + `back_inserter` + `std::vector`, and about 15 times slower than `memcpy` into a raw buffer.  This feels consistent with before-and-after profiling when I switched my real application to custom buffering.

These are all in-memory buffers, so the slowness of iostreams can&#39;t be blamed on slow disk I/O, too much flushing, synchronization with stdio, or any of the other things people use to excuse observed slowness of the C++ standard library iostream.

It would be nice to see benchmarks on other systems and commentary on things common implementations do (such as gcc&#39;s libc++, Visual C++, Intel C++) and how much of the overhead is mandated by the standard.

Rationale for this test
-
A number of people have correctly pointed out that iostreams are more commonly used for formatted output.  However, they are also the only modern API provided by the C++ standard for binary file access.  But the real reason for doing performance tests on the internal buffering applies to the typical formatted I/O: if iostreams can&#39;t keep the disk controller supplied with raw data, how can they possibly keep up when they are responsible for formatting as well?

Benchmark Timing
-

All these are per iteration of the outer (`k`) loop.

On ideone (gcc-4.3.4, unknown OS and hardware):

 * `ostringstream`: 53 milliseconds
 * `stringbuf`: 27 ms
 * `vector&lt;char&gt;` and `back_inserter`: 17.6 ms
 * `vector&lt;char&gt;` with ordinary iterator: 10.6 ms
 * `vector&lt;char&gt;` iterator and bounds check: 11.4 ms
 * `char[]`: 3.7 ms

On my laptop (Visual C++ 2010 x86, `cl /Ox /EHsc`, Windows 7 Ultimate 64-bit, Intel Core i7, 8 GB RAM):

 * `ostringstream`: 73.4 milliseconds, 71.6 ms
 * `stringbuf`: 21.7 ms, 21.3 ms
 * `vector&lt;char&gt;` and `back_inserter`: 34.6 ms, 34.4 ms
 * `vector&lt;char&gt;` with ordinary iterator: 1.10 ms, 1.04 ms
 * `vector&lt;char&gt;` iterator and bounds check: 1.11 ms, 0.87 ms, 1.12 ms, 0.89 ms, 1.02 ms, 1.14 ms
 * `char[]`: 1.48 ms, 1.57 ms

Visual C++ 2010 x86, with Profile-Guided Optimization `cl /Ox /EHsc /GL /c`, `link /ltcg:pgi`, run, `link /ltcg:pgo`, measure:

 * `ostringstream`: 61.2 ms, 60.5 ms
 * `vector&lt;char&gt;` with ordinary iterator: 1.04 ms, 1.03 ms


Same laptop, same OS, using cygwin gcc 4.3.4 `g++ -O3`:

 * `ostringstream`: 62.7 ms, 60.5 ms
 * `stringbuf`: 44.4 ms, 44.5 ms
 * `vector&lt;char&gt;` and `back_inserter`: 13.5 ms, 13.6 ms
 * `vector&lt;char&gt;` with ordinary iterator: 4.1 ms, 3.9 ms
 * `vector&lt;char&gt;` iterator and bounds check: 4.0 ms, 4.0 ms
 * `char[]`: 3.57 ms, 3.75 ms

Same laptop, Visual C++ 2008 SP1, `cl /Ox /EHsc`:

 * `ostringstream`: 88.7 ms, 87.6 ms
 * `stringbuf`: 23.3 ms, 23.4 ms
 * `vector&lt;char&gt;` and `back_inserter`: 26.1 ms, 24.5 ms
 * `vector&lt;char&gt;` with ordinary iterator: 3.13 ms, 2.48 ms
 * `vector&lt;char&gt;` iterator and bounds check: 2.97 ms, 2.53 ms
 * `char[]`: 1.52 ms, 1.25 ms

Same laptop, Visual C++ 2010 64-bit compiler:

 * `ostringstream`: 48.6 ms, 45.0 ms
 * `stringbuf`: 16.2 ms, 16.0 ms
 * `vector&lt;char&gt;` and `back_inserter`: 26.3 ms, 26.5 ms
 * `vector&lt;char&gt;` with ordinary iterator: 0.87 ms, 0.89 ms
 * `vector&lt;char&gt;` iterator and bounds check: 0.99 ms, 0.99 ms
 * `char[]`: 1.25 ms, 1.24 ms


EDIT: Ran all twice to see how consistent the results were.  Pretty consistent IMO.

NOTE: On my laptop, since I can spare more CPU time than ideone allows, I set the number of iterations to 1000 for all methods.  This means that `ostringstream` and `vector` reallocation, which takes place only on the first pass, should have little impact on the final results.

EDIT: Oops, found a bug in the `vector`-with-ordinary-iterator, the iterator wasn&#39;t being advanced and therefore there were too many cache hits.  I was wondering how `vector&lt;char&gt;` was outperforming `char[]`.  It didn&#39;t make much difference though, `vector&lt;char&gt;` is still faster than `char[]` under VC++ 2010.

Conclusions
-
Buffering of output streams requires three steps each time data is appended:

* Check that the incoming block fits the available buffer space.
* Copy the incoming block.
* Update the end-of-data pointer.

The latest code snippet I posted, &quot;`vector&lt;char&gt;` simple iterator plus bounds check&quot; not only does this, it also allocates additional space and moves the existing data when the incoming block doesn&#39;t fit.  As Clifford pointed out, buffering in a file I/O class wouldn&#39;t have to do that, it would just flush the current buffer and reuse it.  So this should be an upper bound on the cost of buffering output.  And it&#39;s exactly what is needed to make a working in-memory buffer.

So why is `stringbuf` 2.5x slower on ideone, and at least 10 times slower when I test it?  It isn&#39;t being used polymorphically in this simple micro-benchmark, so that doesn&#39;t explain it.

Does the C++ standard mandate poor performance for iostreams, or am I just dealing with a poor implementation?

I understand that a stream is a representation of a sequence of bytes.  Each stream provides means for reading and writing bytes to its given backing store.  But what is the point of the stream?  Why isn&#39;t the backing store itself what we interact with?  

For whatever reason this concept just isn&#39;t clicking for me.  I&#39;ve read a bunch of articles, but I think I need an analogy or something.


Can you explain the concept of streams?

Many C++ books contain example code like this...

    std::cout &lt;&lt; &quot;Test line&quot; &lt;&lt; std::endl;

...so I&#39;ve always done that too. But I&#39;ve seen a lot of code from working developers like this instead:

    std::cout &lt;&lt; &quot;Test line\n&quot;;

Is there a technical reason to prefer one over the other, or is it just a matter of coding style?

&quot;std::endl&quot; vs &quot;\n&quot;

I just found a comment in [this][1] answer saying that using `iostream::eof` in a loop condition is &quot;almost certainly wrong&quot;. I generally use something like `while(cin&gt;&gt;n)` - which I guess implicitly checks for EOF.

Why is checking for eof explicitly using `while (!cin.eof())` wrong?  

How is it different from using `scanf(&quot;...&quot;,...)!=EOF` in C (which I often use with no problems)?


  [1]: https://stackoverflow.com/questions/5578631/c-how-do-you-stop-reading-integer-from-text-file-when-encounter-negative-intege/5578649#5578649

Why is iostream::eof inside a loop condition (i.e. `while (!stream.eof())`) considered wrong?

Suppose I have a code like this:

    void printHex(std::ostream&amp; x){
        x&lt;&lt;std::hex&lt;&lt;123;
    }
    ..
    int main(){
        std::cout&lt;&lt;100; // prints 100 base 10
        printHex(std::cout); //prints 123 in hex
        std::cout&lt;&lt;73; //problem! prints 73 in hex..
    }
My question is if there is any way to &#39;restore&#39; the state of `cout` to its original one after returning from the function? (Somewhat like `std::boolalpha` and `std::noboolalpha`..) ?

Thanks.

Restore the state of std::cout after manipulating it

I have the following piece of code that prompts the user for their cat&#39;s age and name:

    #include &lt;iostream&gt;
    #include &lt;string&gt;
    
    int main()
    {
        int age;
        std::string name;

        std::cin &gt;&gt; age;
        std::getline(std::cin, name);
        
        if (std::cin)
        {
            std::cout &lt;&lt; &quot;My cat is &quot; &lt;&lt; age &lt;&lt; &quot; years old and their name is &quot; &lt;&lt; name &lt;&lt; std::endl;
        }
    }

What I find is that the age has been successfully read, but not the name. Here is the input and output:

&gt;     Input:
&gt;
&gt;     &quot;10&quot;
&gt;     &quot;Mr. Whiskers&quot;
&gt;
&gt;     Output:
&gt;
&gt;     &quot;My cat is 10 years old and their name is &quot;

Why has the name been omitted from the output? I&#39;ve given the proper input, but the code somehow ignores it. Why does this happen?

Why does std::getline() skip input after a formatted extraction?

First off, it may seem that I&#39;m asking for subjective opinions, but that&#39;s not what I&#39;m after. I&#39;d love to hear some well-grounded arguments on this topic.

---

**In the hope of getting some insight into how a modern streams / serialization framework ought to be designed,** I recently got myself a copy of the book [_Standard C++ IOStreams and Locales_ by Angelika Langer and Klaus Kreft](http://www.angelikalanger.com/iostreams.html). I figured that if IOStreams wasn&#39;t well-designed, it wouldn&#39;t have made it into the C++ standard library in the first place.

After having read various parts of this book, I am starting to have doubts if IOStreams can compare to e.g. the STL from an overall architectural point-of-view. Read e.g. [this interview with Alexander Stepanov (the STL&#39;s &quot;inventor&quot;)](http://www.stlport.org/resources/StepanovUSA.html) to learn about some design decisions that went into the STL.

**What surprises me in particular**:

* It seems to be unknown who was responsible for IOStreams&#39; overall design (I&#39;d love to read some background information about this &amp;mdash; does anyone know good resources?);

* Once you delve beneath the immediate surface of IOStreams, e.g. if you want to extend IOStreams with your own classes, you get to an interface with fairly cryptic and confusing member function names, e.g. `getloc`/`imbue`, `uflow`/`underflow`, `snextc`/`sbumpc`/`sgetc`/`sgetn`, `pbase`/`pptr`/`epptr` (and there&#39;s probably even worse examples). This makes it so much harder to understand the overall design and how the single parts co-operate. Even the book I mentioned above doesn&#39;t help _that_ much (IMHO).

---

**Thus my question:**

If you had to judge by today&#39;s software engineering standards (if there actually _is_ any general agreement on these), would C++&#39;s IOStreams still be considered well-designed? (I wouldn&#39;t want to improve my software design skills from something that&#39;s generally considered outdated.)

Who architected / designed C++&#39;s IOStreams, and would it still be considered well-designed by today&#39;s standards?

The following **C++** code uses a **ifstream** object to read integers from a text file (which has one number per line) until it hits **EOF**. Why does it read the integer on the last line twice? How to fix this?

**Code:**

    #include &lt;iostream&gt;
    #include &lt;fstream&gt;
    using namespace std;
    
    int main()
    {
    	ifstream iFile(&quot;input.txt&quot;);	// input.txt has integers, one per line
    
    	while (!iFile.eof())
    	{
    		int x;
    		iFile &gt;&gt; x;
    		cerr &lt;&lt; x &lt;&lt; endl;
    	}
    
    	return 0;
    }

**input.txt**:

    10  
    20  
    30

**Output**:

    10  
    20  
    30  
    30

**Note**: I&#39;ve skipped all error checking code to keep the code snippet small. The above behaviour is seen on Windows (Visual C++), cygwin (gcc) and Linux (gcc).


Reading from text file until EOF repeats last line

I tried researching the difference between `cout`, `cerr` and `clog` on the internet but couldn&#39;t find a perfect answer. I still am not clear on when to use which. Can anyone explain to me, through simple programs and illustrate a perfect situation on when to use which one?

I visited [this site][1] which shows a small program on `cerr` and `clog`, but the output obtained over there can also be obtained using `cout`. So, I&#39;m confused over each one&#39;s exact use.


  [1]: http://www.tutorialspoint.com/cplusplus/cpp_basic_input_output.htm

What is the difference between cout, cerr, clog of iostream header in c++? When to use which one?

[Google Code University&#39;s C++ tutorial](http://code.google.com/edu/languages/cpp/basics/getting-started.html#learn-by-example) used to have this code:

    // Description: Illustrate the use of cin to get input
    // and how to recover from errors.
    
    #include &lt;iostream&gt;
    using namespace std;
    
    int main()
    {
      int input_var = 0;
      // Enter the do while loop and stay there until either
      // a non-numeric is entered, or -1 is entered.  Note that
      // cin will accept any integer, 4, 40, 400, etc.
      do {
        cout &lt;&lt; &quot;Enter a number (-1 = quit): &quot;;
        // The following line accepts input from the keyboard into
        // variable input_var.
        // cin returns false if an input operation fails, that is, if
        // something other than an int (the type of input_var) is entered.
        if (!(cin &gt;&gt; input_var)) {
          cout &lt;&lt; &quot;Please enter numbers only.&quot; &lt;&lt; endl;
          cin.clear();
          cin.ignore(10000,&#39;\n&#39;);
        }
        if (input_var != -1) {
          cout &lt;&lt; &quot;You entered &quot; &lt;&lt; input_var &lt;&lt; endl;
        }
      }
      while (input_var != -1);
      cout &lt;&lt; &quot;All done.&quot; &lt;&lt; endl;
    
      return 0;
    }

What is the significance of `cin.clear()` and `cin.ignore()`? Why are the `10000` and `\n` parameters necessary?

Why would we call cin.clear() and cin.ignore() after reading input?

I wanted to compare reading lines of string input from stdin using Python and C++ and was shocked to see my C++ code run an order of magnitude slower than the equivalent Python code. Since my C++ is rusty and I&#39;m not yet an expert Pythonista, please tell me if I&#39;m doing something wrong or if I&#39;m misunderstanding something.

----------
(**TLDR answer:** include the statement: `cin.sync_with_stdio(false)` or just use `fgets` instead.

**TLDR results:** scroll all the way down to the bottom of my question and look at the table.)

----------


**C++ code:**

```c++
#include &lt;iostream&gt;
#include &lt;time.h&gt;

using namespace std;

int main() {
    string input_line;
    long line_count = 0;
    time_t start = time(NULL);
    int sec;
    int lps;

    while (cin) {
        getline(cin, input_line);
        if (!cin.eof())
            line_count++;
    };

    sec = (int) time(NULL) - start;
    cerr &lt;&lt; &quot;Read &quot; &lt;&lt; line_count &lt;&lt; &quot; lines in &quot; &lt;&lt; sec &lt;&lt; &quot; seconds.&quot;;
    if (sec &gt; 0) {
        lps = line_count / sec;
        cerr &lt;&lt; &quot; LPS: &quot; &lt;&lt; lps &lt;&lt; endl;
    } else
        cerr &lt;&lt; endl;
    return 0;
}

// Compiled with:
// g++ -O3 -o readline_test_cpp foo.cpp
```

**Python Equivalent:**

```python
#!/usr/bin/env python
import time
import sys

count = 0
start = time.time()

for line in  sys.stdin:
    count += 1

delta_sec = int(time.time() - start_time)
if delta_sec &gt;= 0:
    lines_per_sec = int(round(count/delta_sec))
    print(&quot;Read {0} lines in {1} seconds. LPS: {2}&quot;.format(count, delta_sec,
       lines_per_sec))
```

**Here are my results:**

```none
$ cat test_lines | ./readline_test_cpp
Read 5570000 lines in 9 seconds. LPS: 618889

$ cat test_lines | ./readline_test.py
Read 5570000 lines in 1 seconds. LPS: 5570000
```

*I should note that I tried this both under Mac&amp;nbsp;OS&amp;nbsp;X&amp;nbsp;v10.6.8 (Snow&amp;nbsp;Leopard) and Linux 2.6.32 (Red Hat Linux 6.2). The former is a MacBook Pro, and the latter is a very beefy server, not that this is too pertinent.*

```bash
$ for i in {1..5}; do echo &quot;Test run $i at `date`&quot;; echo -n &quot;CPP:&quot;; cat test_lines | ./readline_test_cpp ; echo -n &quot;Python:&quot;; cat test_lines | ./readline_test.py ; done
```
```none
Test run 1 at Mon Feb 20 21:29:28 EST 2012
CPP:   Read 5570001 lines in 9 seconds. LPS: 618889
Python:Read 5570000 lines in 1 seconds. LPS: 5570000
Test run 2 at Mon Feb 20 21:29:39 EST 2012
CPP:   Read 5570001 lines in 9 seconds. LPS: 618889
Python:Read 5570000 lines in 1 seconds. LPS: 5570000
Test run 3 at Mon Feb 20 21:29:50 EST 2012
CPP:   Read 5570001 lines in 9 seconds. LPS: 618889
Python:Read 5570000 lines in 1 seconds. LPS: 5570000
Test run 4 at Mon Feb 20 21:30:01 EST 2012
CPP:   Read 5570001 lines in 9 seconds. LPS: 618889
Python:Read 5570000 lines in 1 seconds. LPS: 5570000
Test run 5 at Mon Feb 20 21:30:11 EST 2012
CPP:   Read 5570001 lines in 10 seconds. LPS: 557000
Python:Read 5570000 lines in  1 seconds. LPS: 5570000
```

  [1]: http://c-faq.com/stdio/scanfprobs.html
  [2]: http://c-faq.com/stdio/getsvsfgets.html
  [3]: http://stackoverflow.com/questions/9378500/why-is-splitting-a-string-slower-in-c-than-python

--- 
Tiny benchmark addendum and recap

For completeness, I thought I&#39;d update the read speed for the same file on the same box with the original (synced) C++ code. Again, this is for a 100M line file on a fast disk. Here&#39;s the comparison, with several solutions/approaches:

|Implementation          |    Lines per second|
|:-----------------------|-------------------:|
|python (default)        |           3,571,428|
|cin (default/naive)     |             819,672|
|cin (no sync)           |          12,500,000|
|fgets                   |          14,285,714|
|wc (not fair comparison)|          54,644,808|

Why is reading lines from stdin much slower in C++ than Python?

a.h

    #include &quot;logic.h&quot;
    ...
    
    class A
    {
    friend ostream&amp; operator&lt;&lt;(ostream&amp;, A&amp;);
    ...
    };

logic.cpp

    #include &quot;a.h&quot;
    ...
    ostream&amp; logic::operator&lt;&lt;(ostream&amp; os, A&amp; a)
    {
    ...
    }
    ...

When i compile, it says:

&gt; std::ostream&amp; logic::operator&lt;&lt;(std::ostream&amp;, A&amp;)&#39; must take exactly one argument.

What is the problem?

operator &lt;&lt; must take exactly one argument

I&#39;m in a tutorial which introduces files (how to read from file and write to file)

First of all, this is not a homework, this is just general help I&#39;m seeking.

I know how to read one word at a time, but I don&#39;t know how to read one line at a time, or how to read the whole text file.

What if my file contains 1000 words? It is not practical to read entire file word after word.

My text file named &quot;Read&quot; contains the following:

```none
I love to play games
I love reading
I have 2 books
```

This is what I have accomplished so far:

```cpp
#include &lt;iostream&gt;
#include &lt;fstream&gt;

using namespace std;
int main (){
   
  ifstream inFile;
  inFile.open(&quot;Read.txt&quot;);

  inFile &gt;&gt;
```

Is there any possible way to read the whole file at once, instead of reading each line or each word separately?

How to read a file line by line or a whole text file at once?

I am coding a program that reads data directly from user input and was wondering how could I (without loops) read all data until EOF from standard input. I was considering using `cin.get( input, &#39;\0&#39; )` but `&#39;\0&#39;` is not really the EOF character, that just reads until EOF or `&#39;\0&#39;`, whichever comes first.

Or is using loops the only way to do it? If so, what is the best way?


How to read until EOF from cin in C++

What is the difference between [`printf()`][1] and [`cout`][2] in C++?

  [1]: http://en.cppreference.com/w/cpp/io/c/fprintf
  [2]: http://en.cppreference.com/w/cpp/io/basic_ostream

&#39;printf&#39; vs. &#39;cout&#39; in C++

I&#39;m trying to learn a bit more about how I/O streams work in C++, and I&#39;m really confused at when to use what.

What exactly is a `streambuf`?  
When do I use a `streambuf`, as compared to a `string`, an `istream`, or a `vector`? (I already know the last three, but not how `streambuf` compares to them, if it does at all.)


What exactly is streambuf? How do I use it?

I was trying to solve this exercise  from www.spoj.com : [FCTRL - Factorial][1]

You don&#39;t really have to read it, just do it if you are curious :)

First I implemented it in **C++** (here is my solution):

    #include &lt;iostream&gt;
    using namespace std;
    
    int main() {
    	unsigned int num_of_inputs;
    	unsigned int fact_num;
    	unsigned int num_of_trailing_zeros;
    
    	std::ios_base::sync_with_stdio(false); // turn off synchronization with the C library’s stdio buffers (from https://stackoverflow.com/a/22225421/5218277)
    	
    	cin &gt;&gt; num_of_inputs;
    
    	while (num_of_inputs--)
    	{
    		cin &gt;&gt; fact_num;
    
    		num_of_trailing_zeros = 0;
    
    		for (unsigned int fives = 5; fives &lt;= fact_num; fives *= 5)
    			num_of_trailing_zeros += fact_num/fives;
    
    		cout &lt;&lt; num_of_trailing_zeros &lt;&lt; &quot;\n&quot;;
    	}
    
    	return 0;
    }

I uploaded it as the solution for **g++ 5.1**

The result was: *Time* 0.18 *Mem* 3.3M
[![C++ execution results][2]][2]


But then I saw some comments which claimed that their time execution was less than 0.1. Since I couldn&#39;t think about faster algorithm I tried to implement the same code in **C**:

    #include &lt;stdio.h&gt;
    
    int main() {
    	unsigned int num_of_inputs;
    	unsigned int fact_num;
    	unsigned int num_of_trailing_zeros;
    
    	scanf(&quot;%d&quot;, &amp;num_of_inputs);
    
    	while (num_of_inputs--)
    	{
    		scanf(&quot;%d&quot;, &amp;fact_num);
    
    		num_of_trailing_zeros = 0;
    
    		for (unsigned int fives = 5; fives &lt;= fact_num; fives *= 5)
    			num_of_trailing_zeros += fact_num/fives;
    
    		printf(&quot;%d&quot;, num_of_trailing_zeros);
    		printf(&quot;%s&quot;,&quot;\n&quot;);
    	}
    
    	return 0;
    }

I uploaded it as the solution for **gcc 5.1**

This time the result was: *Time* 0.02 *Mem* 2.1M
[![C execution results][3]][3]

Now the code is *almost the same*, I added `std::ios_base::sync_with_stdio(false);` to the C++ code as was suggested [here][4] to turn off the synchronization with the C library’s stdio buffers. I also split the `printf(&quot;%d\n&quot;, num_of_trailing_zeros);` to `printf(&quot;%d&quot;, num_of_trailing_zeros); printf(&quot;%s&quot;,&quot;\n&quot;);` to compensate for double call of `operator&lt;&lt;` in `cout &lt;&lt; num_of_trailing_zeros &lt;&lt; &quot;\n&quot;;`.

But I still saw **x9 better performance** and lower memory usage in C vs. C++ code.

Why is that?

**EDIT**

I fixed `unsigned long` to `unsigned int` in the C code. It should have been `unsigned int` and the results which are shown above are related to the new (`unsigned int`) version.

  [1]: http://www.spoj.com/problems/FCTRL/
  [2]: http://i.stack.imgur.com/oqpfY.jpg
  [3]: http://i.stack.imgur.com/PgZLu.jpg
  [4]: https://stackoverflow.com/a/22225421/5218277

Big difference (x9) in the execution time between almost identical code in C and C++

What&#39;s the [`&lt;iosfwd&gt;` header][1] used for? Why is it necessary?

Any example?

  [1]: https://en.cppreference.com/w/cpp/header/iosfwd

What is the &lt;iosfwd&gt; header?

I have a C++ program:

**test.cpp**

    #include&lt;iostream&gt;
    
    int main()
    {
    	char t = &#39;f&#39;;
    	char *t1;
    	char **t2;
    	cout&lt;&lt;t;	//this causes an error, cout was not declared in this scope
    	return 0;
    }

I get the **error**:
&gt;&#39;cout&#39; was not declared in this scope

Why?

&#39;cout&#39; was not declared in this scope

In my [earlier question](https://stackoverflow.com/questions/553974/why-does-int55-54-in-c) I was printing a `double` using `cout` that got rounded when I wasn&#39;t expecting it.  How can I make `cout` print a `double` using full precision?

How do I print a double value with full precision using cout?

Hi I was trying to output unicode string to a console with *iostreams* and failed.

I found this:  [Using unicode font in c++ console app][1]  and this snippet works.

    SetConsoleOutputCP(CP_UTF8);
    wchar_t s[] = L&quot;&#232;&#233;&#248;&#222;ǽлљΣ&#230;ča&quot;;
    int bufferSize = WideCharToMultiByte(CP_UTF8, 0, s, -1, NULL, 0, NULL, NULL);
    char* m = new char[bufferSize]; 
    WideCharToMultiByte(CP_UTF8, 0, s, -1, m, bufferSize, NULL, NULL);
    wprintf(L&quot;%S&quot;, m);

However, I did not find any way to output unicode correctly with iostreams. Any suggestions?

This does not work:

    SetConsoleOutputCP(CP_UTF8);
    utf8_locale = locale(old_locale,new boost::program_options::detail::utf8_codecvt_facet());
    wcout.imbue(utf8_locale);
    wcout &lt;&lt; L&quot;&#161;Hola!&quot; &lt;&lt; endl;

**EDIT**
I could not find any other solution than to wrap this snippet around in a stream.
Hope, somebody has better ideas.

    //Unicode output for a Windows console 
    ostream &amp;operator-(ostream &amp;stream, const wchar_t *s) 
    { 
    	int bufSize = WideCharToMultiByte(CP_UTF8, 0, s, -1, NULL, 0, NULL, NULL);
    	char *buf = new char[bufSize];
    	WideCharToMultiByte(CP_UTF8, 0, s, -1, buf, bufSize, NULL, NULL);
    	wprintf(L&quot;%S&quot;, buf);
    	delete[] buf; 
    	return stream; 
    } 
    
    ostream &amp;operator-(ostream &amp;stream, const wstring &amp;s) 
    { 
    	stream - s.c_str();
    	return stream; 
    } 

  [1]: https://stackoverflow.com/questions/1922294/using-unicode-font-in-c-console-app



Output unicode strings in Windows console app

So I was trying to get valid integer input from cin, and used an answer to this [question][1].

It recommended:

    #include &lt;Windows.h&gt; // includes WinDef.h which defines min() max()
    #include &lt;iostream&gt;
    using std::cin;
    using std::cout;
    
    void Foo()
    {
        int delay = 0;
        do
        {
            if(cin.fail())
            {
                cin.clear();
                cin.ignore(std::numeric_limits&lt;std::streamsize&gt;::max(), &#39;\n&#39;);
            }
            cout &lt;&lt; &quot;Enter number of seconds between submissions: &quot;;
        } while(!(cin &gt;&gt; delay) || delay == 0);
    }

Which gives me an error on Windows, saying that the `max` macro doesn&#39;t take that many arguments. Which means I have to do this

    do
    {
        if(cin.fail())
        {
            cin.clear();
    #undef max
            cin.ignore(std::numeric_limits&lt;std::streamsize&gt;::max(), &#39;\n&#39;);
        }
        cout &lt;&lt; &quot;Enter number of seconds between submissions: &quot;;
    } while(!(cin &gt;&gt; delay) || delay == 0);

To get it to work. That&#39;s pretty ugly; is there a better way to work around this issue? Maybe I should be storing the definition of `max` and redefining it afterward?

  [1]: https://stackoverflow.com/questions/5864540/a-simple-question-about-cin/5864560#comment15263994_5864560

How do I deal with the max macro in windows.h colliding with max in std?

I am trying to print a Russian &quot;ф&quot; ([U+0444](http://www.unicode.org/charts/PDF/U0400.pdf) CYRILLIC SMALL LETTER EF) character, which is given a code of decimal [1092][1]. Using C++, how can I print out this character? I would have thought something along the lines of the following would work, yet...

    int main (){
       wchar_t f = &#39;1060&#39;;
       cout &lt;&lt; f &lt;&lt; endl;
    }

  [1]: http://en.wikipedia.org/wiki/%D0%A4

How to print Unicode character in C++?

I&#39;m wondering what techniques and/or library to use to implement the functionality of the linux command &quot;tail -f &lt;filename&gt;&quot;.  I&#39;m essentially looking for a drop in add-on/replacement for `java.io.FileReader`.  Client code could look something like this:

    TailFileReader lft = new TailFileReader(&quot;application.log&quot;);
    BufferedReader br = new BufferedReader(lft);
    String line;
    try {
      while (true) {
        line= br.readLine();
        // do something interesting with line
      }
    } catch (IOException e) {
      // barf
    }


The missing piece is a reasonable implementation of `TailFileReader`.  It should be able to read parts of the file that exist before the file is opened as well as the lines that are added.  

Java IO implementation of unix/linux &quot;tail -f&quot;

What does the *g* stand for in `std::iostream`&#39;s `gcount`, `tellg` and `seekg` members? And the *p* in `pcount`, `tellp` and `seekp`?

Why aren&#39;t they called just `count`, `tell` and `seek`?

What does the g stand for in gcount, tellg and seekg?

I am very new to the C++ STL, so this may be trivial. I have a `ostream` variable with some text in it.

    ostream* pout;
    (*pout) &lt;&lt; &quot;Some Text&quot;;

Is there a way to extract the stream and store it in a string of type `char*`?

Converting ostream into standard string

How can I print 0x0a, instead of 0xa using cout?

    #include  &lt;iostream&gt;
    
    using std::cout;  
    using std::endl;  
    using std::hex;
    
    int main()  
    {  
        cout &lt;&lt; hex &lt;&lt; showbase &lt;&lt; 10 &lt;&lt; endl;  
    }


How can I print 0x0a instead of 0xa using cout?

I download [eclipse for c++][1] (cdt-master-8.0.2.zip).

When I write:

    #include &lt;iostream&gt;

It marks:

    Unresolved inclusion: &lt;iostream&gt;

How can I fix it?

  [1]: http://www.eclipse.org/cdt/downloads.php

How to solve &quot;Unresolved inclusion: &lt;iostream&gt;&quot; in a C++ file in Eclipse CDT?

I usually use `stringstream` to write into in-memory string. Is there a way to write to a char buffer in binary mode? Consider the following code:

    stringstream s;
    s &lt;&lt; 1 &lt;&lt; 2 &lt;&lt; 3;
    const char* ch = s.str().c_str();

The memory at `ch` will look like this: 0x313233 - the ASCII codes of the characters 1, 2 and 3. I&#39;m looking for a way to write the binary values themselves. That is, I want 0x010203 in the memory. The problem is that I want to be able to write a function

    void f(ostream&amp; os)
    {
        os &lt;&lt; 1 &lt;&lt; 2 &lt;&lt; 3;
    }

And decide outside what kind of stream to use. Something like this:

    mycharstream c;
    c &lt;&lt; 1 &lt;&lt; 2 &lt;&lt; 3; // c.data == 0x313233;
    mybinstream b;
    b &lt;&lt; 1 &lt;&lt; 2 &lt;&lt; 3; // b.data == 0x010203;

Any ideas?

Are there binary memory streams in C++

    #include &lt;iostream&gt;
    
    using namespace std;
    
    int main()
    {  
        char          c1 = 0xab;
        signed char   c2 = 0xcd;
        unsigned char c3 = 0xef;
        
        cout &lt;&lt; hex;
        cout &lt;&lt; c1 &lt;&lt; endl;
        cout &lt;&lt; c2 &lt;&lt; endl;
        cout &lt;&lt; c3 &lt;&lt; endl;
    }

I expected the output are as follows:

    ab
    cd
    ef

Yet, I got nothing.

I guess this is because cout always treats &#39;char&#39;, &#39;signed char&#39;, and &#39;unsigned  char&#39; as characters rather than 8-bit integers. However, &#39;char&#39;, &#39;signed char&#39;, and &#39;unsigned  char&#39; are all integral types.

So my question is: How to output a character as an integer through cout?

PS: static_cast&lt;int&gt;(...) is ugly and needs more work to trim extra bits.

How to output a character as an integer through cout?

I&#39;m currently learning C++ (Coming from Java) and I&#39;m trying to understand how to use IO streams properly in C++. 

Let&#39;s say I have an `Image` class which contains the pixels of an image and I overloaded the extraction operator to read the image from a stream:

    istream&amp; operator&gt;&gt;(istream&amp; stream, Image&amp; image)
    {
        // Read the image data from the stream into the image
        return stream;
    }

So now I&#39;m able to read an image like this:

    Image image;
    ifstream file(&quot;somepic.img&quot;);
    file &gt;&gt; image;

But now I want to use the same extraction operator to read the image data from a custom stream. Let&#39;s say I have a file which contains the image in compressed form. So instead of using ifstream I might want to implement my own input stream. At least that&#39;s how I would do it in Java. In Java I would write a custom class extending the `InputStream` class and implementing the `int read()` method. So that&#39;s pretty easy. And usage would look like this:

    InputStream stream = new CompressedInputStream(new FileInputStream(&quot;somepic.imgz&quot;));
    image.read(stream);

So using the same pattern maybe I want to do this in C++:

    Image image;
    ifstream file(&quot;somepic.imgz&quot;);
    compressed_stream stream(file);
    stream &gt;&gt; image;

But maybe that&#39;s the wrong way, don&#39;t know. Extending the `istream` class looks pretty complicated and after some searching I found some hints about extending `streambuf` instead. But this [example][1] looks terribly complicated for such a simple task. 

So what&#39;s the best way to implement custom input/output streams (or streambufs?) in C++?



Solution
========

Some people suggested not using iostreams at all and to use iterators, boost or a custom IO interface instead. These may be valid alternatives but my question was about iostreams. The accepted answer resulted in the example code below. For easier reading there is no header/code separation and the whole std namespace is imported (I know that this is a bad thing in real code).

This example is about reading and writing vertical-xor-encoded images. The format is pretty easy. Each byte represents two pixels (4 bits per pixel). Each line is xor&#39;d with the previous line. This kind of encoding prepares the image for compression (usually results in lot of 0-bytes which are easier to compress).

    #include &lt;cstring&gt;
    #include &lt;fstream&gt;

    using namespace std;

    /*** vxor_streambuf class ******************************************/

    class vxor_streambuf: public streambuf
    {
    public:
        vxor_streambuf(streambuf *buffer, const int width) :
            buffer(buffer),
            size(width / 2)
        {
            previous_line = new char[size];
            memset(previous_line, 0, size);
            current_line = new char[size];
            setg(0, 0, 0);
            setp(current_line, current_line + size);
        }
        
        virtual ~vxor_streambuf()
        {
            sync();
            delete[] previous_line;
            delete[] current_line;
        }
        
        virtual streambuf::int_type underflow()
        {
            // Read line from original buffer
            streamsize read = buffer-&gt;sgetn(current_line, size);
            if (!read) return traits_type::eof();

            // Do vertical XOR decoding
            for (int i = 0; i &lt; size; i += 1)
            {
                current_line[i] ^= previous_line[i];
                previous_line[i] = current_line[i];
            }

            setg(current_line, current_line, current_line + read);
            return traits_type::to_int_type(*gptr());
        }

        virtual streambuf::int_type overflow(streambuf::int_type value)
        {
            int write = pptr() - pbase();
            if (write)
            {
                // Do vertical XOR encoding
                for (int i = 0; i &lt; size; i += 1)
                {
                    char tmp = current_line[i];
                    current_line[i] ^= previous_line[i];
                    previous_line[i] = tmp;
                }

                // Write line to original buffer
                streamsize written = buffer-&gt;sputn(current_line, write);
                if (written != write) return traits_type::eof();
            }

            setp(current_line, current_line + size);
            if (!traits_type::eq_int_type(value, traits_type::eof())) sputc(value);
            return traits_type::not_eof(value);
        };
        
        virtual int sync()
        {
            streambuf::int_type result = this-&gt;overflow(traits_type::eof());
            buffer-&gt;pubsync();
            return traits_type::eq_int_type(result, traits_type::eof()) ? -1 : 0;
        }
        
    private:
        streambuf *buffer;
        int size;
        char *previous_line;
        char *current_line;
    };


    /*** vxor_istream class ********************************************/

    class vxor_istream: public istream
    {
    public:
        vxor_istream(istream &amp;stream, const int width) :
            istream(new vxor_streambuf(stream.rdbuf(), width)) {}
        
        virtual ~vxor_istream()
        {
            delete rdbuf();
        }
    };


    /*** vxor_ostream class ********************************************/

    class vxor_ostream: public ostream
    {
    public:
        vxor_ostream(ostream &amp;stream, const int width) :
            ostream(new vxor_streambuf(stream.rdbuf(), width)) {}
        
        virtual ~vxor_ostream()
        {
            delete rdbuf();
        }
    };


    /*** Test main method **********************************************/

    int main()
    {
        // Read data
        ifstream infile(&quot;test.img&quot;);
        vxor_istream in(infile, 288);
        char data[144 * 128];
        in.read(data, 144 * 128);
        infile.close();

        // Write data
        ofstream outfile(&quot;test2.img&quot;);
        vxor_ostream out(outfile, 288);
        out.write(data, 144 * 128);
        out.flush();
        outfile.close();

        return 0;
    }

  [1]: http://icodesnip.com/snippet/cpp/an-example-of-implementing-a-custom-streambuf-performs-xor-encryption-dreamincode

How to write custom input stream in C++

Is there a reason to use `endl` with `cout` when I can  just use `\n`? My C++ book says to use endl, but I don&#39;t see why. Is `\n` not supported as widely as `endl`, or am I missing something?



Why use endl when I can use a newline character?

I get these error messages for all `cout` and `endl`:

    main.cc:17:5: error: ‘cout’ was not declared in this scope
    main.cc:17:5: note: suggested alternative:
    /usr/include/c++/4.6/iostream:62:18: note:   ‘std::cout’

After following the suggestion, everything is fine. Now I am curious, why I had to do that. We used C++ in classes before, but I never had to write a `std::` before any of those commands. What might be different on this system?


Why std::cout instead of simply cout?

Most C++ users that learned C prefer to use the `printf` / `scanf` family of functions even when they&#39;re coding in C++.

Although I admit that I find the interface way better (especially POSIX-like format and localization), it seems that an overwhelming concern is performance.

Taking at look at this question:

&gt; [How can I speed up line by line reading of a file][1]

It seems that the best answer is to use `fscanf` and that the C++ `ifstream` is consistently 2-3 times slower.

I thought it would be great if we could compile a repository of &quot;tips&quot; to improve IOStreams performance, what works, what does not.

Points to consider

 - buffering (`rdbuf()-&gt;pubsetbuf(buffer, size)`)
 - synchronization (`std::ios_base::sync_with_stdio`)
 - locale handling (Could we use a trimmed-down locale, or remove it altogether ?)

Of course, other approaches are welcome.

*Note: a &quot;new&quot; implementation, by Dietmar Kuhl, was mentioned, but I was unable to locate many details about it. Previous references seem to be dead links.*

  [1]: https://stackoverflow.com/questions/5164538/how-can-i-speed-up-line-by-line-reading-of-an-ascii-file-c/

How to get IOStream to perform better?

Given this C++11 program, should I expect to see a number or a letter?  Or not make expectations?

    #include &lt;cstdint&gt;
    #include &lt;iostream&gt;
    
    int main()
    {
        int8_t i = 65;
        std::cout &lt;&lt; i;
    }

Does the standard specify whether this type can or will be a character type?

All Iostream Solutions on Gang of Coders

Total of 47 Iostream Solutions