Lecture 5 Files and Streams

Transcription

1 Lecture 5 Files and Streams

2 Introduction C programs can store results & information permanently on disk using file handling functions These functions let you write either text or binary data to a file, and read this information back later All file access is controlled by a file pointer :- a pointer to a structure which is created when you open a file contains information about the file you opened Once the file is opened, refer to file via this pointer, NOT by its name. The file pointer is a variable of type FILE

3 FILE *

4 FILE *

5 FILE * As you can see FILE * is a complex structure which holds information about the file system. This information differs from different operating systems, and file system types. To make the C language portable an abstraction is used The C library contains a number of file access functions which use the FILE * abstraction to process the information

6 C++ File operations C++ provides a number of classes to perform output and input of characters to / from files These are specified to allow read, write, and read / write Unlike C these classes have different names as follows ofstream : A stream class to write to files ifstream : A stream class to read from files fstream : A stream class to both read and write from/to files.

7 Get File Name File processing : order of Open File with open operations File Open? No Report Error yes Read or write DATA no FINISHED? yes Close File close end

8 Opening a file To open a file we need to create a file object of the correct type. Once this is done we use the open method to see if the file can be accessed. In the following example we open a file for writing 1 #include <fstream> std::ofstream FileOut; 5 6 FileOut.open("File.txt",std::ios::out); 7 // check to see if we can open the file 8 if (!FileOut.is_open()) 9 { 10 std::cerr <<"Could not open File for writing "<<std::endl; 11 exit(exit_failure); 12 }

9 Stream IO When a file is opened a file descriptor is returned and this file descriptor is used for each subsequent I/O operation, when any operation is carried out on the file descriptor its is known as a stream. When a stream is opened the stream object created is used for all subsequent file operations not the file name.

10 std::fstream open method 1 void open ( const char * filename, ios_base::openmode mode = ios_base::out ); The open method takes two parameters. By default we only need to specify one which is the name of the file to access. However we can pass an additional mode parameter which allows us to specify different operations such as read/write. Also we can specify if the data is to be written as text (default) or binary

11 flag value std::ios_base::app std::ios_base::ate IO Modes opening mode (append) Set the stream's position indicator to the end of the stream before each output operation. (at end) Set the stream's position indicator to the end of the stream on opening. std::ios_base:: binary (binary) Consider stream as binary rather than text. std::ios_base:: in std::ios_base:: out std::ios_base:: trunc (input) Allow input operations on the stream. (output) Allow output operations on the stream. (truncate) Any current content is discarded, assuming a length of zero on opening.

12 checking file open Once the stream object s open method has been called we can check to see if it was successful 1 #include <fstream> std::ofstream FileOut; 5 6 FileOut.open("File.txt",std::ios::out); 7 // check to see if we can open the file 8 if (!FileOut.is_open()) 9 { 10 std::cerr <<"Could not open File for writing "<<std::endl; 11 exit(exit_failure); 12 }

13 closing a file close when a program finishes with a file it should close it using close method 1 FileOut.close(); close performs housekeeping tasks such as flushing (emptying) buffers and breaking connections with the stream object.

14 Reading and writing a Stream Once a stream has been opened there are three types of unformatted I/O which may be performed these are as follow 1. Character at a time I/O. 2. Line at a time I/O 3. Direct I/O

15 Access to the file Once the stream object is associated to a file we use the insertion and extraction operators to read and write data << is the insertion operator and can be used to write data to the stream object >> is the extraction operator and can be used to read data from the stream object These operators are overloaded to work with all standard data types There are also a number of methods for character / line at a time I/O

16 1 #include <iostream> 2 #include <fstream> 3 #include <string> 4 #include <cstdlib> 5 6 int main(int argc, char *argv[]) 7 { 8 if (argc <=1) 9 { 10 std::cerr <<"Usage FileWrite [filename] "<<std::endl; 11 exit(exit_failure); 12 } std::ofstream FileOut; FileOut.open(argv[1],std::ios::out); 17 // check to see if we can open the file 18 if (!FileOut.is_open()) 19 { 20 std::cerr <<"Could not open File : "<<argv[1]<<" for writing "<<std::endl; 21 exit(exit_failure); 22 } int a=10; 25 char b='c'; 26 float c=22.3; 27 double d= ; 28 std::string s("hello file transfer"); FileOut<<a<<std::endl; 31 FileOut<<b<<std::endl; 32 FileOut<<c<<std::endl; 33 FileOut<<d<<std::endl; 34 FileOut<<s<<std::endl; FileOut.close(); 37 return EXIT_SUCCESS; 38 } Insertion example c hello file transfer

17 1 #include <iostream> 2 #include <fstream> 3 #include <string> 4 #include <cstdlib> 5 6 int main(int argc, char *argv[]) 7 { 8 if (argc <=1) 9 { 10 std::cerr <<"Usage FileWrite [filename] "<<std::endl; 11 exit(exit_failure); 12 } std::ifstream FileIn; FileIn.open(argv[1]); 17 // check to see if we can open the file 18 if (!FileIn.is_open()) 19 { 20 std::cerr <<"Could not open File : "<<argv[1]<<" for reading "<<std::endl; 21 exit(exit_failure); 22 } int a; 25 char b; 26 float c; 27 double d; 28 std::string s; FileIn>>a; 31 FileIn>>b; 32 FileIn>>c; 33 FileIn>>d; 34 FileIn>>s; FileIn.close(); 37 std::cout << a<<"\n"<<b<<"\n"<<c<<"\n"<<d<<"\n"<<s<<std::endl; return EXIT_SUCCESS; 40 } c hello extraction example Note that the >> method for the string only reads to the 1st space

18 Input Functions To input a character we use the get method This inputs a character at a time from the specified stream This is shown in the following example.

19 1 #include <iostream> 2 #include <fstream> 3 #include <cstdlib> 4 5 int main(int argc, char *argv[]) 6 { 7 if (argc <=1) 8 { 9 std::cerr <<"Usage FileWrite [filename] "<<std::endl; 10 exit(exit_failure); 11 } std::ifstream FileIn; FileIn.open(argv[1]); 16 // check to see if we can open the file 17 if (!FileIn.is_open()) 18 { 19 std::cerr <<"Could not open File : "<<argv[1]<<" for writing "<<std::endl; 20 exit(exit_failure); 21 } 22 char data; 23 while (!FileIn.eof() ) 24 { 25 FileIn.get(data); 26 std::cout <<data; 27 } 28 std::cout<<std::endl; 29 FileIn.close(); 30 return EXIT_SUCCESS; 31 } Open file for reading and check if ok loop until we reach the end of the file (eof) Use the get method to read a character into the variable data

20 Output Functions To output characters we can use the put method This outputs a character at a time to the specified stream This is shown in the following example.

21 1 #include <iostream> 2 #include <fstream> 3 #include <cstdlib> 4 5 int main(int argc, char *argv[]) 6 { 7 if (argc <=2) 8 { 9 std::cerr <<"Usage FileWrite [infile] [outfile] "<<std::endl; 10 exit(exit_failure); 11 } std::ofstream FileOut; 14 std::ifstream FileIn; FileIn.open(argv[1]); 17 FileOut.open(argv[2]); // check to see if we can open the file 20 if (!FileOut.is_open() &&!FileIn.is_open()) 21 { 22 std::cerr <<"Could not open one of the files : "<<std::endl; 23 exit(exit_failure); 24 } while(!filein.eof()) 27 FileOut.put(FileIn.get()); FileOut.close(); 30 FileIn.close(); return EXIT_SUCCESS; 33 } Open two file streams and check if ok While not eof on the input file get a char from the ip file and write it to the op file

22 Line at a time I/O The previous functions have all used character at a time processing. When dealing with text files we can use line at a time I/ O The line is usually terminated with the newline character \n If we are writing a line we place the NULL (\0) char to specify the end.

23 Line Input Line at a time input is provided by the following function 1 istream& getline ( istream&, string& str, char delim ); 2 istream& getline ( istream&, string& str ); This function is passed an open stream to read from A string object to read the data too Additionally we can specify a delimiter to specify when to terminate the current read operation By default this is the \n character but we can change this to any character we like.

24 1 #include <iostream> 2 #include <fstream> 3 #include <string> 4 #include <cstdlib> int main(int argc, char *argv[]) 8 { 9 if (argc <=1) 10 { 11 std::cout <<"Usage FileRead [filename] "<<std::endl; 12 exit(exit_failure); 13 } std::fstream FileIn; 16 FileIn.open(argv[1],std::ios::in); 17 if (!FileIn.is_open()) 18 { 19 std::cout <<"File : "<<argv[1]<<" Not found Exiting "<<std:: endl; 20 exit(exit_failure); 21 } std::string LineBuffer; 24 unsigned long int LineNumber=1; 25 while(!filein.eof()) 26 { 27 getline(filein,linebuffer,'\n'); 28 std::cout <<LineNumber<<" : "<<LineBuffer<<std::endl; 29 ++LineNumber; 30 } 31 FileIn.close(); 32 return EXIT_SUCCESS; 33 } open file for reading Declare a string to store data use getline to read up to the \n character

25 Reading from the console 1 #include <iostream> 2 #include <string> 3 #include <cstdlib> 4 5 int main(void) 6 { 7 std::cout << "Please enter a line:\n"; 8 std::string s; 9 getline(cin,s); 10 std::cout << "You entered " << s << '\n'; 11 return EXIT_SUCCESS; 12 } by using cin we can read from the console

26 Binary I/O The previous functions operated with either one character at a time or a line at a time Sometimes desirable to read or write complete structures to or from a file. This is done using the following binary I/O functions 1 std::istream& read(char *buffer, std::streamsize num); 2 std::ostream& write(const char *buffer, std::streamsize num);

27 Binary I/O Example write 1 #include <iostream> 2 #include <fstream> 3 #include <string> 4 #include <cstdlib> class Point 8 { 9 public : 10 float x; 11 float y; 12 float z; 13 }; int main(int argc, char *argv[]) 16 { if (argc <=1) 19 { 20 std::cout <<"Usage BinaryWrite [filename] "<<std::endl; 21 exit(exit_failure); 22 } std::ofstream FileOut; 25 FileOut.open(argv[1],std::ios::out std::ios::binary); 26 if (!FileOut.is_open()) 27 { 28 std::cout <<"File : "<<argv[1]<<" Not found Exiting "<<std:: endl; 29 exit(exit_failure); 30 } Point p[100]; for(int i=0; i<100; ++i) 35 { 36 p[i].x=i; p[i].y=i; p[i].z=i; 37 } FileOut.write(reinterpret_cast <char *>(p),sizeof(point)*100); FileOut.close(); 42 return EXIT_SUCCESS; 43 } A class to hold data open a file for binary output Fill data with values (100) write out data

28 reinterpret_cast<>() As the read and write functions expect a pointer to character data we need to coerce the Point class to think it s a char * To do this we use 1 reinterpret_cast <char *>(p) This works in this case as the public elements of the class are the only elements seen to the coercion In some cases this is not same and it is best to write a file in and out method for the class

29 Binary I/O Example read 1 #include <iostream> 2 #include <fstream> 3 #include <string> 4 #include <cstdlib> 5 6 using namespace std; 7 8 class Point{ 9 public : 10 float x; 11 float y; 12 float z; 13 }; int main(int argc, char *argv[]) 16 { if (argc <=1) 19 { 20 std::cout <<"Usage BinaryRead [filename] "<<std::endl; 21 exit(exit_failure); 22 } std::ifstream FileIn; 25 FileIn.open(argv[1],std::ios::in std::ios::binary); 26 if (!FileIn.is_open()) 27 { 28 std::cout <<"File : "<<argv[1]<<" Not found Exiting "<<std:: endl; 29 exit(exit_failure); 30 } 31 Point p[100]; 32 FileIn.read(reinterpret_cast <char *>(p),sizeof(point)*100); for(int i=0; i<100; ++i) 35 std::cout <<"["<<p[i].x<<","<<p[i].y<<","<<p[i].z<<"]\n"; FileIn.close(); 39 return EXIT_SUCCESS; 40 } A class to hold data open a file for binary input Read in data print it out

30 Positioning a stream There are several functions which allow the programmer to move the current position of the file stream. These are as follows 1. seekg and seekp. allow us to move to a position in the stream 2. tellg and tellp allow us to determine the current position in the stream.

31 Positioning a stream These functions allow us to change the position of the get and put stream pointers. Both functions are overloaded with two different prototypes. The first prototype is: 1 seekg ( position ); 2 seekp ( position ); Using this prototype the stream pointer is changed to the absolute position position (counting from the beginning of the file). The type for this parameter is the same as the one returned by functions tellg and tellp: the member type pos_type, which is an integer value. The other prototype for these functions is: 1 seekg ( offset, direction ); 2 seekp ( offset, direction );

32 positioning a stream The position element from the previous function can be one of the following std::ios::beg offset counted from the beginning of the stream std::ios::cur offset counted from the current position of the stream pointer std::ios::end offset counted from the end of the stream

33 File Parsing It is common to want to read information from a config file and setup a programs state dependent upon the information in the file One of the easiest methods is to read the text file a line at a time and split the line into tokens which can be acted upon We will re-visit this idea later in the year once we ve learnt some more C++

34 References Advanced Programming in the Unix Environment, W. Richard Stevens. Addison Wesley