Google Groups no longer supports new Usenet posts or subscriptions. Historical content remains viewable.

Dismiss

Groups keyboard shortcuts have been updated

Dismiss

See shortcuts

Different behavior of ifstream and istrstream. What about istringstream?

9 views

Skip to first unread message

Alex Vinokur

unread,

Jul 13, 1999, 3:00:00 AM7/13/99

Hi,

We have got different results using iostream and ifstream.
(Please see below).

What about istringstream?
Note. <sstream> is missing on my compiler.

Thanks in advance,
Alex

//#########################################################
//------------------- C++ code : BEGIN -------------------
#include <iostream>
#include <fstream>
#include <string>
#include <strstream>
#include <assert.h>

int main ()
{
unsigned int int_element = 7777;
istrstream int_stream ("111 222 333");
ifstream int_data_file ("int_data");
assert (int_data_file);

char chars_element[100];
istrstream chars_stream ("AAA1 AAA2 AAA3");
ifstream chars_data_file ("chars_data");
assert (chars_data_file);

char one_char_element = 'T';
istrstream one_char_stream ("XYZ");
ifstream one_char_data_file ("one_char_data");
assert (one_char_data_file);

int i;

//============== int_stream ==============
i = 0;
cout << endl;
cout << endl;
while ((int_stream >> int_element).good())
{
++i;
cout << "istrstream to int_element : Step#"
< rdstate = "
<< int_stream.rdstate ()
<< endl;

i = 0;
cout << endl;
while ((int_data_file >> int_element).good())
{
++i;
cout << "ifstream to int_element : Step#"
< rdstate = "
<< int_data_file.rdstate ()
<< endl;

//============== chars_stream ==============
i = 0;
cout << endl;
cout << endl;
while ((chars_stream >> chars_element).good())
{
++i;
cout << "istrstream to chars_element : Step#"
< rdstate = "
<< chars_stream.rdstate ()
<< endl;

i = 0;
cout << endl;
while ((chars_data_file >> chars_element).good())
{
++i;
cout << "ifstream to chars_element : Step#"
< rdstate = "
<< chars_data_file.rdstate ()
<< endl;

//============== one_char_stream ==============
i = 0;
cout << endl;
cout << endl;
while ((one_char_stream >> one_char_element).good())
{
++i;
cout << "istrstream to one_char_element : Step#"
< rdstate = "
<< one_char_stream.rdstate ()
<< endl;

i = 0;
cout << endl;
while ((one_char_data_file >> one_char_element).good())
{
++i;
cout << "ifstream to one_char_element : Step#"
< rdstate = "
<< one_char_data_file.rdstate ()
<< endl;

//=================
return 0;

}

//------------------- C++ code : END ----------------------

//#########################################################
//------------------- Data Files : BEGIN ------------------

# --- int_data file ---
111
222
333

# --- chars_data file ---
aaa1
aaa2
aaa3

# --- one_char_data file ---
xyz

//------------------- Data Files : END --------------------

//#########################################################
//------------------- Running Results : BEGIN -------------

istrstream to int_element : Step#1 : rdstate = 0
istrstream to int_element : Step#2 : rdstate = 0
istrstream to int_element : Step#3 : rdstate = 0
istrstream to int_element : End -> rdstate = 3

ifstream to int_element : Step#1 : rdstate = 0
ifstream to int_element : Step#2 : rdstate = 0
ifstream to int_element : Step#3 : rdstate = 0
ifstream to int_element : End -> rdstate = 3

istrstream to chars_element : Step#1 : rdstate = 0
istrstream to chars_element : Step#2 : rdstate = 0
istrstream to chars_element : End -> rdstate = 1
// ATTENTION: end rdstate = 1
// ATTENTION: only two steps

ifstream to chars_element : Step#1 : rdstate = 0
ifstream to chars_element : Step#2 : rdstate = 0
ifstream to chars_element : Step#3 : rdstate = 0
ifstream to chars_element : End -> rdstate = 3

istrstream to one_char_element : Step#1 : rdstate = 0
istrstream to one_char_element : Step#2 : rdstate = 0
istrstream to one_char_element : Step#3 : rdstate = 0
istrstream to one_char_element : End -> rdstate = 3

ifstream to one_char_element : Step#1 : rdstate = 0
ifstream to one_char_element : Step#2 : rdstate = 0
ifstream to one_char_element : Step#3 : rdstate = 0
ifstream to one_char_element : End -> rdstate = 3

//------------------- Running Results : END ---------------

//#########################################################
//------------------- Compiler & System ------------------

g++ -v : gcc version egcs-2.91.57 19980901
(egcs-1.1 release)

uname -a : SunOS <nodename> 5.6 Generic_105181-09
sun4m sparc SUNW,SPARCstation-5

//---------------------------------------------------------

//#########################################################

Sent via Deja.com http://www.deja.com/
Share what you know. Learn what you don't.

Alex Vinokur

unread,

Jul 13, 1999, 3:00:00 AM7/13/99

In article <7mf1da$eem$1...@nnrp1.deja.com>,

Alex Vinokur <alexande...@telrad.co.il> wrote:
>
>
> Hi,
>
> We have got different results using iostream and ifstream.

Sorry. It must be as following :
We have got different results using istrstream and ifstream.

[snip]
Alex.

Brandon Wallace

unread,

Jul 13, 1999, 3:00:00 AM7/13/99

1) Your input streams *are* different.
If you want them to be the same, then
you should make the following changes:

istrstream int_stream("111\n222\n333\n");
istrstream chars_stream("AAA1\nAAA2\nAAA3\n");
istrstream one_char_stream ("XYZ\n");

Note the newline characters between each element.
And you didn't say or not, but most likely the
3 datafiles have a newline character on the last
line, so I add those also.

2) You shouldn't test using .good() because .good() returns
false if eof has been read.
You should test like so:

while (int_stream >> int_element)

while (!(int_stream >> int_element).fail())

The problem you are experiencing is that when the final element
is read, the eof is read also. So .good() evaluates to false and
kicks out of the loop. But .fail() is false also, that is why
the rdstate is different than you expect.

--
You are wandering aimlessly through the forest.

Alex Vinokur

unread,

Jul 14, 1999, 3:00:00 AM7/14/99

In article <378B4594...@houston.nacm.com>,
Brandon Wallace <bm...@houston.nacm.com> wrote:
[snip]

>
> 2) You shouldn't test using .good() because .good() returns
> false if eof has been read.
> You should test like so:
>
> while (int_stream >> int_element)
>
> or
>
> while (!(int_stream >> int_element).fail())
>
> The problem you are experiencing is that when the final element
> is read, the eof is read also. So .good() evaluates to false and
> kicks out of the loop. But .fail() is false also, that is why
> the rdstate is different than you expect.
>

[snip]

Hi,

Thank you very much.

Using fail() instead of good () causes almost consistent results (see
Note)

But what about istringstream?
(The <sstream> file is missing on my compiler)

Thanks in advance,
Alex

int i;

while (!((int_stream >> int_element).fail()))

{
++i;
cout << "istrstream to int_element : Step#"
< rdstate = "
<< int_stream.rdstate ()
<< endl;

cout << "istrstream to int_element : "
<< (int_stream.eof () ? "OK" : "ERROR")
<< endl;

//----------------

i = 0;
cout << endl;

while (!((int_data_file >> int_element).fail()))

{
++i;
cout << "ifstream to int_element : Step#"
< rdstate = "
<< int_data_file.rdstate ()
<< endl;

cout << "ifstream to int_element : "
<< (int_data_file.eof () ? "OK" : "ERROR")
<< endl;

//============== chars_stream ==============
i = 0;
cout << endl;
cout << endl;

while (!((chars_stream >> chars_element).fail()))

{
++i;
cout << "istrstream to chars_element : Step#"
< rdstate = "
<< chars_stream.rdstate ()
<< endl;

cout << "istrstream to chars_element : "
<< (chars_stream.eof () ? "OK" : "ERROR")
<< endl;

//----------------

i = 0;
cout << endl;

while (!((chars_data_file >> chars_element).fail()))

{
++i;
cout << "ifstream to chars_element : Step#"
< rdstate = "
<< chars_data_file.rdstate ()
<< endl;

cout << "ifstream to chars_element : "
<< (chars_data_file.eof () ? "OK" : "ERROR")
<< endl;

//============== one_char_stream ==============
i = 0;
cout << endl;
cout << endl;

while (!((one_char_stream >> one_char_element).fail()))

{
++i;
cout << "istrstream to one_char_element : Step#"
< rdstate = "
<< one_char_stream.rdstate ()
<< endl;

cout << "istrstream to one_char_element : "
<< (one_char_stream.eof () ? "OK" : "ERROR")
<< endl;
//----------------

i = 0;
cout << endl;

while (!((one_char_data_file >> one_char_element).fail()))

{
++i;
cout << "ifstream to one_char_element : Step#"
< rdstate = "
<< one_char_data_file.rdstate ()
<< endl;

cout << "ifstream to one_char_element : "
<< (one_char_data_file.eof () ? "OK" : "ERROR")
<< endl;

//=================
return 0;

}

//------------------- C++ code : END ----------------------

//#########################################################
//------------------- Data Files : BEGIN ------------------

# --- int_data file ---
111
222
333

# --- chars_data file ---
aaa1
aaa2
aaa3

# --- one_char_data file ---
xyz

//------------------- Data Files : END --------------------

//#########################################################
//------------------- Running Results : BEGIN -------------

istrstream to int_element : Step#1 : rdstate = 0
istrstream to int_element : Step#2 : rdstate = 0
istrstream to int_element : Step#3 : rdstate = 0
istrstream to int_element : End -> rdstate = 3

istrstream to int_element : OK

ifstream to int_element : Step#1 : rdstate = 0
ifstream to int_element : Step#2 : rdstate = 0
ifstream to int_element : Step#3 : rdstate = 0
ifstream to int_element : End -> rdstate = 3

ifstream to int_element : OK

istrstream to chars_element : Step#1 : rdstate = 0
istrstream to chars_element : Step#2 : rdstate = 0

istrstream to chars_element : Step#3 : rdstate = 1 // Note!
istrstream to chars_element : End -> rdstate = 3
istrstream to chars_element : OK

ifstream to chars_element : Step#1 : rdstate = 0
ifstream to chars_element : Step#2 : rdstate = 0
ifstream to chars_element : Step#3 : rdstate = 0
ifstream to chars_element : End -> rdstate = 3

ifstream to chars_element : OK

istrstream to one_char_element : OK

ifstream to one_char_element : OK

Brandon Wallace

unread,

Jul 14, 1999, 3:00:00 AM7/14/99

Once again, the most likely culprit in the inconsistancy you
are seeing is that the input data you are
providing is *different* between the file version and the string version.
In the file, your data probably has a finaly newline character,
but in the string it does not. This means that when the
final read is done, it successfully reads (! fail()), but
in the strstream case, it detects the eof character (rdstate==1)
while in the fstream case, it stopped at the final newline (whitespace).
It doesn't detect eof until the next read.

Change your input data for the strstreams and see if that makes things
consistant.

fstreams, strstreams, stringstreams, streams should all behave
the same given exactly the same input under normal situations

--
There is one art of which man should be master -- the art of reflection.
-- Coleridge

Alex Vinokur

unread,

Jul 18, 1999, 3:00:00 AM7/18/99

In article <378CA691...@houston.nacm.com>,

Brandon Wallace <bm...@houston.nacm.com> wrote:
> Once again, the most likely culprit in the inconsistancy you
> are seeing is that the input data you are
> providing is *different* between the file version and the string
version.
> In the file, your data probably has a finaly newline character,
> but in the string it does not. This means that when the
> final read is done, it successfully reads (! fail()), but
> in the strstream case, it detects the eof character (rdstate==1)
> while in the fstream case, it stopped at the final newline
(whitespace).
> It doesn't detect eof until the next read.
>
> Change your input data for the strstreams and see if that makes things
> consistant.
>
> fstreams, strstreams, stringstreams, streams should all behave
> the same given exactly the same input under normal situations
>

[snip]

Thank you very much.
1. Here is a consistent example.
2. But I have a new question (see one_char_stream_2).
Can we read space from istrstream to one_char_var?
While reading one_char_stream_2 the space is ignored.
Alex

//#########################################################
//------------------- C++ code : BEGIN -------------------

#include <iostream>
#include <fstream>
#include <string>
#include <strstream>

#include <iomanip.h>
#include <assert.h>

const int setw_stream_class_name_CNS = 11;
const int setw_stream_object_name_CNS = 20;
const int setw_variable_name_CNS = 9;

template <typename T1>
void print_start_status (
const string& stream_class_name_i,
const string& stream_object_name_i,
const T1& stream_object_i,
const string& variable_name_i
)
{

cout.setf(ios::left, ios::adjustfield);
cout << setw (setw_stream_class_name_CNS)
<< stream_class_name_i.c_str()
<< " "
<< setw (setw_stream_object_name_CNS)
<< stream_object_name_i.c_str()
<< " to "
<< setw (setw_variable_name_CNS)
<< variable_name_i.c_str()
<< endl;

}

template <typename T1, typename T2>
void print_step_status (
const T1& stream_object_i,
const T2& variable_i,
int step_number_i
)
{
cout.setf(ios::left, ios::adjustfield);
cout << setw (setw_stream_class_name_CNS)
<< " "
<< " "
<< "--> Step#"
<< step_number_i
<< " : rdstate = "
<< stream_object_i.rdstate ()
<< "; variable = "
<< variable_i
<< endl;
}

template <typename T1>
void print_end_status (
const string& stream_class_name_i,
const string& stream_object_name_i,
const T1& stream_object_i,
const string& variable_name_i
)
{

#define PRINT_START_STATUS(streamClassName, streamObject, variable) \
print_start_status(#streamClassName, #streamObject,
streamObject, #variable)

#define PRINT_STEP_STATUS(streamObject, variable, stepNo) \
print_step_status(streamObject, variable, stepNo)

#define PRINT_END_STATUS(streamClassName, streamObject, variable) \
print_end_status(#streamClassName, #streamObject, streamObject,
#variable)

#define WHILE_LOOP(streamClassName, streamObject, variable) \
cout << endl; \
PRINT_START_STATUS (streamClassName, streamObject, variable); \
stepNo = 0; \
while (!((streamObject >> variable).fail())) \
{ \
PRINT_STEP_STATUS (streamObject, variable, ++stepNo); \
} \
PRINT_END_STATUS (streamClassName, streamObject, variable); \
cout << endl;

//====================================================
//====================================================
int main ()
{
//===============================================
unsigned int int_var;
istrstream int_stream ("100 200 300 400 500");

//-------------------------

ifstream int_data_file ("int_data");

///////////////////////////////////////////////////////
// Here is the int_data file
///////////////////////////////////////////////////////
// 111 222 333
// 444
// 555
///////////////// using od -c (dump-command) //////////
// 0000000 1 1 1 2 2 2 3 3 3 \n 4 4 4
\n
// 0000020 5 5 5 \n
// 0000024
///////////////////////////////////////////////////////

assert (int_data_file);
//===============================================

//===============================================
char chars_var [100];
istrstream chars_stream_1 ("AAA1 AAA2 AAA3 AAA4 AAA5");
istrstream chars_stream_2 ("BBB1 BBB2 BBB3 BBB4 BBB5\n");
istrstream chars_stream_3 ("CCC1\nCCC2\nCCC3\nCCC4\nCCC5\n");

//-------------------------

ifstream chars_data_file ("chars_data");

///////////////////////////////////////////////////////
// Here is the chars_data file
///////////////////////////////////////////////////////
// aaa1 aaa2 aaa3
// aaa4
// aaa5
///////////////// using od -c (dump-command) //////////
// 0000000 a a a 1 a a a 2 a a a 3 \n
a
// 0000020 a a 4 \n a a a 5 \n
// 0000031
///////////////////////////////////////////////////////

assert (chars_data_file);
//===============================================

//===============================================
char one_char_var;
istrstream one_char_stream_1 ("XYZUT");
istrstream one_char_stream_2 ("F H\n\nKLI");

//-------------------------

ifstream one_char_data_file ("one_char_data");

///////////////////////////////////////////////////////
// Here is the one_char_data file
///////////////////////////////////////////////////////
// xyz
// t
// u
///////////////// using od -c (dump-command) //////////
// 0000000 x y z \n t \n u \n
// 0000010
///////////////////////////////////////////////////////

assert (one_char_data_file);
//===============================================

int stepNo;

//============== int_stream ==============
WHILE_LOOP (istrstream, int_stream, int_var);
WHILE_LOOP (ifstream, int_data_file, int_var);

//============== chars_stream... ============
WHILE_LOOP (istrstream, chars_stream_1, chars_var);
WHILE_LOOP (istrstream, chars_stream_2, chars_var);
WHILE_LOOP (istrstream, chars_stream_3, chars_var);
WHILE_LOOP (ifstream, chars_data_file, chars_var);

//============== one_char_stream_1 ==============
WHILE_LOOP (istrstream, one_char_stream_1, one_char_var);
WHILE_LOOP (istrstream, one_char_stream_2, one_char_var);
WHILE_LOOP (ifstream, one_char_data_file, one_char_var);

//=================
return 0;

}

//------------------- C++ code : END ----------------------

//#########################################################

//------------------- Running Results : BEGIN -------------

istrstream int_stream to int_var
--> Step#1 : rdstate = 0; variable = 100
--> Step#2 : rdstate = 0; variable = 200
--> Step#3 : rdstate = 0; variable = 300
--> Step#4 : rdstate = 0; variable = 400
--> Step#5 : rdstate = 0; variable = 500
istrstream int_stream to int_var : End -> rdstate = 3
istrstream int_stream to int_var : OK

ifstream int_data_file to int_var
--> Step#1 : rdstate = 0; variable = 111
--> Step#2 : rdstate = 0; variable = 222
--> Step#3 : rdstate = 0; variable = 333
--> Step#4 : rdstate = 0; variable = 444
--> Step#5 : rdstate = 0; variable = 555
ifstream int_data_file to int_var : End -> rdstate = 3
ifstream int_data_file to int_var : OK

istrstream chars_stream_1 to chars_var
--> Step#1 : rdstate = 0; variable = AAA1
--> Step#2 : rdstate = 0; variable = AAA2
--> Step#3 : rdstate = 0; variable = AAA3
--> Step#4 : rdstate = 0; variable = AAA4
--> Step#5 : rdstate = 1; variable = AAA5
istrstream chars_stream_1 to chars_var : End -> rdstate = 3
istrstream chars_stream_1 to chars_var : OK

istrstream chars_stream_2 to chars_var
--> Step#1 : rdstate = 0; variable = BBB1
--> Step#2 : rdstate = 0; variable = BBB2
--> Step#3 : rdstate = 0; variable = BBB3
--> Step#4 : rdstate = 0; variable = BBB4
--> Step#5 : rdstate = 0; variable = BBB5
istrstream chars_stream_2 to chars_var : End -> rdstate = 3
istrstream chars_stream_2 to chars_var : OK

istrstream chars_stream_3 to chars_var
--> Step#1 : rdstate = 0; variable = CCC1
--> Step#2 : rdstate = 0; variable = CCC2
--> Step#3 : rdstate = 0; variable = CCC3
--> Step#4 : rdstate = 0; variable = CCC4
--> Step#5 : rdstate = 0; variable = CCC5
istrstream chars_stream_3 to chars_var : End -> rdstate = 3
istrstream chars_stream_3 to chars_var : OK

ifstream chars_data_file to chars_var
--> Step#1 : rdstate = 0; variable = aaa1
--> Step#2 : rdstate = 0; variable = aaa2
--> Step#3 : rdstate = 0; variable = aaa3
--> Step#4 : rdstate = 0; variable = aaa4
--> Step#5 : rdstate = 0; variable = aaa5
ifstream chars_data_file to chars_var : End -> rdstate = 3
ifstream chars_data_file to chars_var : OK

istrstream one_char_stream_1 to one_char_var
--> Step#1 : rdstate = 0; variable = X
--> Step#2 : rdstate = 0; variable = Y
--> Step#3 : rdstate = 0; variable = Z
--> Step#4 : rdstate = 0; variable = U
--> Step#5 : rdstate = 0; variable = T
istrstream one_char_stream_1 to one_char_var : End -> rdstate = 3
istrstream one_char_stream_1 to one_char_var : OK

istrstream one_char_stream_2 to one_char_var
--> Step#1 : rdstate = 0; variable = F
--> Step#2 : rdstate = 0; variable = H
--> Step#3 : rdstate = 0; variable = K
--> Step#4 : rdstate = 0; variable = L
--> Step#5 : rdstate = 0; variable = I
istrstream one_char_stream_2 to one_char_var : End -> rdstate = 3
istrstream one_char_stream_2 to one_char_var : OK

ifstream one_char_data_file to one_char_var
--> Step#1 : rdstate = 0; variable = x
--> Step#2 : rdstate = 0; variable = y
--> Step#3 : rdstate = 0; variable = z
--> Step#4 : rdstate = 0; variable = t
--> Step#5 : rdstate = 0; variable = u
ifstream one_char_data_file to one_char_var : End -> rdstate = 3
ifstream one_char_data_file to one_char_var : OK

0 new messages