Thread: only first line being extracted from file

Well, for one, your not returning the string. I'll just give a simple example and hold back on the explanations/critiqueing for now (or just let someone else do it). I don't use C++ streams as much as most folks, here (still pretty C, in that respect), so I'm sure you get even better, 'modern' examples from others, but here's an idea:

Code:

 string read(const char * file)
{
 string buffer, temp;
 
 ifstream in(file);
 
     if(in)
    {
         while(in >> temp)
        {
         buffer += temp + " ";
        } 
    }
 
 return buffer; 
}

 int main(int, char ** argv)
{
     while(*(++argv))
    { 
     cout << read(*argv) << endl;
    }
    
 return cin.get();
}

It's not really that efficient to return temporaries like that, though, and besides, you don't get an honest to god return value to tell you whether or not it failed, so I'd prefer the much more modest:

Code:

//returns the number of 'tokens' read

 int read(const char * file, string & buffer)
{
 int result = -1;

 string temp;
 
 ifstream in(file);

 buffer = "";
 
     if(in)
    {
      result = 0; // start the counter

         while(in >> temp)
        {
         buffer += temp + " ";
 
         ++result;
        } 
    }
 
 return result; 
}

Hope that helps.

Originally Posted by whackaxe

hi there. i'm writing a small function that reads a file (how original ) i tried this but it's only returning the first line. and then quiting

Code:

string C_fsystem::readLine(void)
{
ifstream TMP_file;
string TMP_buffer;
TMP_file.open(fullName().c_str());
if (TMP_file.fail()){cout<<"error opening file. quitting";cin.get();exit(1);}
while (!TMP_file.eof())
      {
      getline(TMP_file,TMP_buffer);
      cout<<TMP_buffer;
      }
TMP_file.close();
}

fullName() returns a string with the file name and everything goes fine. it read the first line then breaks off.

any ideas?

If you wrote the file in binary mode and are reading it in text mode you could be having problems. If the data contains a text mode interpretation of a binary EOF character then it could be quiting prematurly thinking that it has reached the end of the file. Just a thought... Maybe you could post the file or the first few lines of it at least?

Originally Posted by hk_mp5kpdw

If you wrote the file in binary mode and are reading it in text mode you could be having problems. If the data contains a text mode interpretation of a binary EOF character then it could be quiting prematurly thinking that it has reached the end of the file.

There is not an EOF character in files that says they are at the end of data. No matter what is being read or how it is being read, the only time the end of the file is reached is when the file pointer reaches the end of the data contained in the file.

Originally Posted by LuckY

There is not an EOF character in files that says they are at the end of data. No matter what is being read or how it is being read, the only time the end of the file is reached is when the file pointer reaches the end of the data contained in the file.

Then the following code when run on my machine is not doing what it is supposed to be doing:

Code:

#include <fstream>
#include <iostream>
#include <string>
using namespace std;

int main()
{
    // Open the file for writing in binary mode
    ofstream output("Test.txt",ios::binary|ios::out);
    int data = 26;
    output << "This is before the int.";
    output.write((char*)&data,sizeof(int));    // Output int to the file, 26 = Ctrl-Z
    output << "This is after the int.";
    output.close();

    //  Open the file for reading now in text mode.
    ifstream input("Test.txt");
    string str;
    while( getline(input,str) )
        cout << str << endl;
    input.close();

    return 0;
}

Resulting output is:

Code:

This is before the int.

If I remove the write of the variable data then the output becomes:

Code:

This is before the int.This is after the int.

No, Lucky's right. There isn't actually an EOF character. It's just a value that's returned by read functions to indicate that the file-pointer has reached the end of data. As to why the file seemed truncated when an int was reached was simply because the string now has a binary reprepresention of an integer between the two pieces of text and, since the integer contains three zero's before the '26' (remember there's four bytes to an int [usually]), 'cout' stops writing once it reaches one of those zero's (since strings are null-terminated). To see this yourself, just set the integer to 1094795585, and try the test again. You should see 'AAAA' between the text.