File I/O in C++

1. File I/O in C++

2. Using Input/Output Files A computer file • is stored on a secondary storage device (e.g., disk); • is permanent; • can be used to provide input data to a program or receive output data from a program, or both; • should reside in Project directory for easy access; • must be opened before it is used.

3. General File I/O Steps • Declare a file name variable • Associate the file name variable with the disk file name • Open the file • Use the file • Close the file

4. Using Input/Output Files • stream - a sequence of characters • interactive (iostream)  cin - input stream associated with keyboard.  cout - output stream associated with display. • file (fstream)  ifstream - defines new input stream (normally associated with a file).  ofstream - defines new output stream (normally associated with a file).

5. Stream I/O Library Header Files • Note: There is no “.h” on standard header files : <fstream> • iostream -- contains basic information required for all stream I/O operations • iomanip -- contains information useful for performing formatted I/O with parameterized stream manipulators • fstream -- contains information for performing file I/O operations • strstream -- contains information for performing in-memory I/O operations (i.e., into or from strings in memory)

6. Classes for Stream I/O in C++ • ios is the base class. • istream and ostream inherit from ios • ifstream inherits from istream (and ios) • ofstream inherits from ostream (and ios) • iostream inherits from istream and ostream (& ios) • fstream inherits from ifstream, iostream, and ofstream

7. C++ streams #include <fstream> int main (void) { //Local declarations ifstream fsIn; ofstream fsOut; . . . return 0; }

8. Object and Member Functions input_stream.open("numbers.dat") Stream handle Name Member Function Name File Name Dot Operator Calling Object

9. File I/O Example: Writing #include <fstream> using namespace std; int main(void) { ofstream outFile(“fout.txt"); outFile << "Hello World!"; outFile.close(); return 0; }

10. File I/O Example: Writing #include <fstream> using namespace std; int main(void) { ofstream outFile; outFile.open(“fout.txt”); outFile << “First line”; //behave just like cout outFile.close(); outFile<<“Another line”<<endl; //?? return 0; }

11. File I/O Example: Reading #include <iostream> #include <fstream> int main(void) { ifstream openFile(“data.txt"); //open a text file data.txt char ch; while(!OpenFile.eof()) { OpenFile.get(ch); cout << ch; } OpenFile.close(); return 0; }

12. File I/O Example: Reading #include <iostream> #include <fstream> #include <string> int main(void) { ifstream openFile(“data.txt"); //Declare and open a text file string line; while(!openFile.eof()) { getline(openFile,line);//fetch line from data.txt and put it in a string cout << line; } openFile.close(); return 0; }

13. File I/O Example: Reading #include <iostream> #include <fstream> #include <string> int main(void) { ifstream openFile(“data.txt"); //open a text file data.txt string line; if(openFile.is_open()){ // while(!openFile.eof()){ getline(openFile,line);//read a line from data.txt and put it in a string cout << line; } else{ cout<<“File does not exist!”<<endl; exit(1);} } openFile.close(); return 0; }

14. More Input File-Related Functions • ifstream fsin; • fsIn.open(constchar[] fname) • connects stream fsIn to the external file fname. • fsIn.get(char& character) • extracts next character from the input stream fsIn and places it in the character variable character. • fsIn.eof() • tests for the end-of-file condition.

15. More Output File-Related Functions • ofstream fsOut; • fsOut.open(constchar[] fname) • connects stream fsOut to the external file fname. • fsOut.put(char character) • inserts character character to the output stream fsOut. • fsOut.eof() • tests for the end-of-file condition.

16. File Open Mode

17. File Open Mode #include <fstream> int main(void) { ofstream outFile("file1.txt", ios::out); outFile << "That's new!\n"; outFile.close(); Return 0; } If you want to set more than one open mode, just use the OR operator- |. This way: ios::ate | ios::binary

18. Dealing with Binary files • Functions for binary file handling get(): read a byte and point to the next byte to read put(): write a byte and point to the next location for write read(): block reading write(): block writing

19. Dealing with Binary files • Some useful functions seekg():Go to a specific position when reading seekp():Go to a specific position when writing tellg(): Retunrs an int type, that shows the current position of the inside-pointer. This one works only when you read a file. tellp():The same as tellg() but used when we write in a file. flush():Save data from the buffer to the output file.

20. Binary File I/O Examples //Example 1: Using get() and put() #include <iostream> #include <fstream> void main() { fstream File("test_file",ios::out | ios::in | ios::binary); char ch; ch='o'; File.put(ch); //put the content of ch to the file File.seekg(ios::beg); //go to the beginning of the file File.get(ch); //read one character cout << ch << endl; //display it File.close(); }

21. Binary File I/O Examples //Example 2: Using read() and write() #include <fstream.h> #include <string.h> void main() { fstream File("test_file.txt",ios::out | ios::in | ios::binary); char arr[13]; strcpy(arr,"Hello World!"); //put Hello World! into the array File.write(arr,5); //put the first 5 symbols into the file- "Hello" File.seekg(ios::beg); //go to the beginning of the file static char read_array[10]; //I will put the read data, here File.read(read_array,3); //read the first 3 symbols- "Hel" cout << read_array << endl; //display them File.close(); }

22. More Binary File I/O Examples #include <fstream> void main() { //if we have "Hello" in test_file.txt ifstream File("test_file.txt"); char arr[10]; File.read(arr,10); //this should return 5, as Hello is 5 characters long cout << File.tellg() << endl; File.close(); }

23. Summary of InputFile-Related Functions #include <fstream> ifstream fsIn; • fsIn.open(constchar[] fname) • connects streamfsInto the external filefname. • fsIn.get(char& c) • extracts next character from the input stream fsIn and places it in the character variable c. • fsIn.eof() • tests for the end-of-file condition. • fsIn.close() • disconnects the stream and associated file. • fsIn >> c; //Behaves just like cin

24. Summary of OutputFile-Related Functions #include <fstream> ofstream fsOut; • fsOut.open(constchar[] fname) • connects streamfsOutto the external filefname. • fsOut.put(char c) • inserts character c to the output stream fsOut. • fsOut.eof() • tests for the end-of-file condition. • fsOut.close() • disconnects the stream and associated file. • fsOut << c;//Behaves just like cout