Now in this chapter, we shall read about the following concepts:
- few useful functions
- other ways to open a file
- cross checking the fstream variable
- read from & write to file simultaneously
So far we saw only one way of opening the file as per the following syntax.
ifstream file("filename.txt");
Well, this is not the only way! As mentioned before, the above code creates an object from class ifstream, and passes the name of the file to be opened to its constructor. But in fact, there are several overloaded constructors, which can take more than one parameter. Also, there is function open() that can do the same job. Here is an example of the above code, but using the open() function:
ifstream file;
file.open("filename.txt");
What is the difference you ask? Well, there is no difference! Just if you want to create a file handle, but don’t want to specify the file name immediately, you can specify it later with the function open(). And by the way, other use of open() is for example if you open a file, then close it, and using the same file handle open another file. This way, you will need the open() function.
Consider the following code example:
#include
void read (ifstream &T)
{
char ch;
while(!T.eof())
{
T.get(ch);
cout << ch;
}
cout << endl << "---" << endl;
}
void main()
{
ifstream T("filename1.txt");
read(T);
T.close();
T.open("filename2.txt");
read(T);
T.close();
}
So, as long as filename1.txt and filename2.txt exists and has some text into, you will see it!
Now, it’s time to show you that the file name is not the only parameter that you can pass to the open() function or the constructor (it’s the same). Here is a prototype:
ifstream file(char *filename, int open_mode);
You should know that filename is the name of the file (a string). The new content here is the open mode. The value of open_mode defines how to be opened the file. Here is a table of the open modes:
| Name | Description |
|---|---|
| ios::in | Open file to read |
| ios::out | Open file to write |
| ios::app | All the date you write, is put at the end of the file. It calls ios::out |
| ios::ate | All the date you write, is put at the end of the file. It does not call ios::out |
| ios::trunc | Deletes all previous content in the file. (empties the file) |
| ios::nocreate | If the file does not exists, opening it with the open() function gets impossible. |
| ios::noreplace | If the file exists, trying to open it with the open() function, returns an error. |
| ios::binary | Opens the file in binary mode. |
In fact, all these values are int constants from an enumerated type. But for making your life easier, you can use them as you see them in the table.
Here is an example on how to use the open modes:
#include
void main()
{
ofstream file("filename1.txt", ios::ate);
file << "Write at end of file\n";
file.close();
}
As you see in the table, using ios::ate will write at the end of the file. If we didn’t use it, the file will be overwritten, but because of it, we can just add text to it. So, if filename1.txt has this text:
Hi! Good morning!
Running the above code, will add “That’s new!” to it, so it will look this way:
Hi! Good morning!Write at end of file
If you want to set more than one open mode, just use the OR operator as follows:
ios::ate | ios::binary
Now, it’s time to read something really useful! Till now we saw how to read from or write to file, but not done using same fstream handler. Now let us see how it works:
fstream file("filename.txt", ios::in | ios::out);
In fact, that is only the declaration. I will show you a code example, just several lines bellow. But I first want to mention some things you should know.
The code line above, creates a file stream handle, named “file”. As you know, this is an object from class fstream. When using fstream, you should specify ios::in and ios::out as open modes. This way, you can read from the file, and write in it, in the same time, without creating new file handles. Well, of course, you can only read or write. Then you should use either ios::in either ios::out, but if you are going to do it this way, why don’t you do it either with ifstream, either with ofstream?
Here is the code example:
#include
void main()
{
fstream File("filename.txt",ios::in | ios::out);
file << "Hi!"; //put "Hi!" in the file;
static char str[10];
file.seekg(ios::beg); //get back to the beginning of the file //this function is explained a bit later
file >> str;
cout << str << endl;
file.close();
}
Let me explain line by line bcause of many new things.
fstream File("filename.txt", ios::in | ios::out); - This line, creates an object from class fstream. At the time of execution, the program opens the file test.txt in read/write mode. This means, that you can read from the file, and put data into it, at the same time.
file << "Hi!"; - We already know this.
static char str[10]; - This makes a char array with 10 cells. Since static may be unfamiliar to you. If so- ignore it. It just initializes the array when at the time of creation.
file.seekg(ios::beg); - This line makes the pointer that is responsiable of reading and writing the text to the begining of the file.
while(!OpenFile.eof())
{
file.get(ch);
cout << ch;
}
This is a while loop, that will loop until you reach the end of the file. But how do the loop know if the end of the file is reached? Well, when you read the file, there is something like an inside-pointer, that shows where you are up to, with the reading (and writing, too). It is like the cursor in Notepad. And every time you call file.get(ch) it returns the current character to the ch variable, and moves the inside-pointer one character after that, so that the next time this function is called, it will return the next character. And this repeats, until you reach the end of the file.
Now the function seekg() will put the inside-pointer to a specific place (specified by you). You can use:
ios::beg - to put it in the beginning of the file
ios::end - to put it at the end of the file
Or you can also set the number of characters to go back or after. For example, if you want to go 5 characters back, you should write:
file.seekg(-5);
If you want to go 40 character after, just write:
file.seekg(40);
I also have to mention, that the seekg() function is overloaded, and it can take two parameters, too. The other version is this one:
file.seekg(-5,ios::end);
In this example, you will be able to read the last 4 characters of the text, because:
1) You go to the end (ios::end)
2) You go 5 characters before the end (-5)
Why you will read 4 but not 5 characters? Well, just assume that one is lost, because the last thing in the file is not a character nor white space. It is just position.
file >> str; - That’s new, too! Well, I believe this line reminds you of cin >> . I fact, it has much to do with it. This line reads one word from the file, and puts it into the specified array.
For example, if the file has this text:
Hi! How are you?
Using file >> str, will put just “Hi!” to the str array. You should have noticed, that it actually reads until it meets a white space.
And as what I put in the file was “Hi!” I don’t need to do a while loop, that takes more time to code. That’s why I used this way. By the way, in the while loop for reading, that I used so far, the program reads the file, char by char. But you can read it word by word, this way:
char str[30]; //the word can’t be more than 30 characters long
while(!file.eof())
{
file >> str;
cout << str;
}
You can also read it line by line, this way:
char line[100]; //a whole line will be stored here
while(!file.eof())
{
file.getline(line,100); //where 100 is the size of the array
cout << line << endl;
}
You now might be wondering which way to use? Well, I’d recommend you to use the line-by-line one, or the first that I mentioned- the one which reads char-by-char. The one that reads word-by-word is not good idea, because it won’t read the new line. So if you have new line in the file, it will not display it as a new line, but will append the text to the existing one. But using getline() or get() will show you the file, just as it is!
Now, I will show you how to check if the file opening was successful or not. In fact, there are few good ways to check for that, and I will mention them. Notice that where there is X, it can be either “o”, either “i” either nothing (it will then be fstream object).
Example 1: The most usual way
Xfstream file("filename.txt");
if (!File)
{
cout << "Error opening the file! Aborting…\n";
exit(1);
}
Example 2: If the file is created, return an error
ofstream file("file_non_existing.txt", ios::nocreate);
if(!File)
{
cout << "Error opening the file! Aborting…\n";
exit(1);
}
Example 3: Using the fail() function
ofstream file("filename.txt", ios::nocreate);
if(file.fail())
{
cout << "Error opening the file! Aborting…\n";
exit(1);
}
The new in Example 3, is the fail() function. It returns a nonzero value if any I/O error (not end of file) has occurred.
I would also like to mention about something , that I find to be very useful! For example, if you have created a file stream, but you haven’t opened a file. This way:
ifstream file; //it could also be ofstream
This way, we have a handle, but we still have not opened the file. If you want to open it later, it can be done with the open() function, which I already covered in this tutorial. But if anywhere in your program, you need to know if currently there is an opened file, you can check it with the function is_open(). It retunrs 0 (false) if a file is not opened, and 1 (true) if there is an opened file. For example:
ofstream file;
file.open("filename.txt");
cout << file.is_open() << endl;
The code above, will return 1, as we open a file (on line 2). But the code bellow will return 0, because we don’t open a file, but just create a file stream handle:
ofstream file;
cout << file.is_open() << endl;
This way we can use the functions and other things provided.
No comments:
Post a Comment