I/O std::basic_streambuf put and get areas?

[Steven T. Hatton]

I'm a bit confused about a statement in TC++ST §13.10. It's in reference to
this example:

/* The following code example is taken from the book
* "The C++ Standard Library - A Tutorial and Reference"
* by Nicolai M. Josuttis, Addison-Wesley, 1999
*
* (C) Copyright Nicolai M. Josuttis 1999.
* Permission to copy, use, modify, sell and distribute this software
* is granted provided this copyright notice appears in all copies.
* This software is provided "as is" without express or implied
* warranty, and with no claim as to its suitability for any purpose.
*/
#include <iostream>
#include <fstream>
using namespace std;

int main()
{
// open file ``example.dat'' for reading and writing
filebuf buffer;
ostream output(&buffer);
istream input(&buffer);
buffer.open ("example.dat", ios::in | ios:ut | ios::trunc);

for (int i=1; i<=4; i++) {
// write one line
output << i << ". line" << endl;

// print all file contents
input.seekg(0); // seek to the beginning
char c;
while (input.get(c)) {
cout.put(c);
}
cout << endl;
input.clear(); // clear eofbit and failbit
}
}

He says "Although two different stream objects are used for reading and
writing, the read and write positions are tightly coupled. seekg() and
seekp() call the same member function of the stream buffer.10"

footnote 10 says: "Actually this function can distinguish whether the read
position, the write position, or both positions are to be modified. Only
the standard stream buffers maintain one position for reading and writing."

This is the Doxygen of libstdc++:
http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/istream_8tcc-source.html#l00967

I'm trying to make heads or tails out of this. If the put pointer and get
pointer are synchronized, then why have two of them? This is what the
std::basic_streambuf pointer declarations look like:

Protected Attributes
locale _M_buf_locale
char_type * _M_in_beg
char_type * _M_in_cur
char_type * _M_in_end
char_type * _M_out_beg
char_type * _M_out_cur
char_type * _M_out_end

 

[Maxim Yegorushkin]

On Sun, 03 Jul 2005 08:35:11 +0400, Steven T. Hatton

[]

http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/istream_8tcc-source.html#l00967
I'm trying to make heads or tails out of this. If the put pointer and
get
pointer are synchronized, then why have two of them?

Because you may want to maintain different file positions for read and
write in your streambuf. Why prohibit it?

This is what the
std::basic_streambuf pointer declarations look like:

Protected Attributes
locale _M_buf_locale
char_type * _M_in_beg
char_type * _M_in_cur
char_type * _M_in_end
char_type * _M_out_beg
char_type * _M_out_cur
char_type * _M_out_end

Please note, these are buffer positions, not file.

 

[Jonathan Turkanis]

I'm trying to make heads or tails out of this. If the put pointer
and get pointer are synchronized, then why have two of them? This is
what the std::basic_streambuf pointer declarations look like:

Among other things, you can use a stream buffer with separate get and put areas
to create an iostream representing a TCP connection, with separate input and
output channels.

Jonathan

 

[Steven T. Hatton]

Among other things, you can use a stream buffer with separate get and put
areas to create an iostream representing a TCP connection, with separate
input and output channels.

Jonathan

I was tired when I posted that. What I was really trying to get at is
whether that specification has changed since he wrote the book. And also
whether I /could/ create a buffer that had independed put and get areas.
And also how the condition he was describing was produced. None of that
was clear to me from looking at the source, but I had not studied it very
closely. DR60 is kind of long, and I wasn't able to determine exactly what
the note in the implementation was reffering to.