c++ i/o and other topics
DESCRIPTION
C++ I/O and Other Topics. Using C++ Stream I/O. Default input stream is called cin Default output stream is called cout Use the extraction operator >> with cin Use the insertion operatorTRANSCRIPT
CMSC 202 1
C++ I/O and Other Topics
CMSC 202 2
Using C++ Stream I/O
• Default input stream is called cin
• Default output stream is called cout
• Use the extraction operator >> with cin
• Use the insertion operator << with cout
• We will see later that cin and cout are actually objects
CMSC 202 3
Using cin• integers and floats
cin >> i1 >> f1; // skips over whitespace
• characters
cin >> ch1 >> ch2; // skips over whitespace
To not skip whitespace, use cin.get:
ch = cin.get(); // reads any character
CMSC 202 4
Using cin (con’t)• strings (char*)
cin >> str; // reads until first whitespace
Better to use cin.getline:
cin.getline(str, buffer_size, end_char);
where buffer_size = size of str, including ‘\0’
end_char = character to stop at
Reading stops when end_char is encountered, the end-of-file is encountered, or when buffer_size-1 has been exceeded. ‘\n’ is the default for end_char. Automatically appends ‘\n’ to the string.
CMSC 202 5
Using cout
• integers and floats
cout << i1 << f1; // displayed in default format
• characters
cout << ch; // single character displayed
• strings (char*)
cout << str; // displays up to ‘\0’ character
CMSC 202 6
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
CMSC 202 7
C++ File I/O
• Declare a file name variable
#include <fstream.h>
ifstream input_filename_var; // input file
ofstream output_filename_var; // output file
CMSC 202 8
C++ File I/O (con’t)
• Associate the file name variable with the disk file name and open it
input_filename_var.open(“pathname/filename”, ios::in);
output_filename_var.open(“pathname/filename”, ios::out);
where ios::in and ios::out are optional
Files may be opened in other modes such as ios::app (append) and ios::binary (binary input or output)
CMSC 202 9
C++ File I/O (con’t)
File name declaration and opening/association may be combined:
ifstream input_filename_var(pathname/filename, ios::in);
ofstream input_filename_var(pathname/filename, ios::out);
where ios::in and ios::out are optional
CMSC 202 10
C++ File I/O (con’t)• Use the file
• Use an input file as you would use the cin input stream
ifile1 >> x >> y; // x and y are integers
ifile2 >> ch; // ch is a char
ch = ifile3.get(); // ch is a char
ifile4.getline(buffer, buffer_size) // buffer is char*
CMSC 202 11
C++ File I/O (con’t)
• Use an output file as you would use the cout output stream
ofile1 << x << y; // x and y are integers
ofile2 << ch; // ch is a char
ofile3 << “Hi there!” << endl; // literal string
ofile4 << str; // str is a char*
CMSC 202 12
C++ File I/O (con’t)
• Close the file
input_filename_var.close();
output_filename_var.close();
All files are closed automatically upon termination of program execution, but it is a good habit to close them explicitly. Also, close them as soon as they are no longer needed by the program.
CMSC 202 13
Checking That Files Have Opened Successfully
• Always check that all files (input or output) have been successfully opened
• If any file cannot be opened, send a message to the user and terminate program execution
ifstream myFile(“inputData”);
if (!myFile) {
cerr << “Input file could not be opened” << endl;
exit(1); // must #include <stdlib.h> to use exit function
}
CMSC 202 14
Checking for End-of-Fileifstream inFile(“somefile.txt”);
. . .
if (inFile) . . . OR while (inFile) . . .
Checks to see if the last operation on inFile was successful. If yes, then the condition is true; otherwise, it is false.
So, if the last operation was a read, then you are checking to see if the end-of-file has been reached.
CMSC 202 15
Sample Program Using File I/O#include <fstream.h>
#include <iostream.h>
#include <stdlib.h>
void main() {
ifstream inFile(“numbers.dat”);
int x;
if (!inFile) {
cerr << “Cannot open input file. Exiting.” << endl;
exit(1);
}
CMSC 202 16
Sample Program (con’t)
inFile >> x;
while (inFile) { // OR while (inFile >> x) and
inFile >> x; // omit the priming read
cout << x << endl;
}
inFile.close();
}
CMSC 202 17
Passing by ReferenceIn C:
swap(&x, &y); // call passes addresses
void swap(int* x, int* y) { // ptrs receive addresses
int temp;
temp = *x; // dereference pointer
*x = *y; // dereference pointers
*y = temp; // dereference pointer
}
CMSC 202 18
Passing by Reference (con’t)In C++:
swap(x, y); // just pass variable
void swap(int& x, int&y) { // x and y are references
int temp;
temp = x; // no dereferencing
x = y; // no dereferencing
y = temp; // no dereferencing
}
CMSC 202 19
Constants#define PI 3.14
Preprocessor replaces all occurrences of PI with the value 3.14. #define actually defines a macro.
const int PI = 3.14;
Is not replaced by the processor. Value cannot be changed -- runtime error.
CMSC 202 20
Other C++ Topics
• Can us endl in place of ‘\n’
• Variables can be declared anywhere in C++ code (but pick a logical place)
• Output can be formatted by using stream manipulators (e.g., setw, setprecision) (Ch. 11.6)
• Namespaces - now part of ANSI C++ (Ch. 21)
CMSC 202 21
Other Things to be Aware of (both C and C++)
• in-line functions
• avoids a function call by “advising” the compiler to generate a copy of the function in place of each call
• faster execution, but larger object file
inline float area(int h, int w) { return h * w}
int main() . . .
CMSC 202 22
Other Things to be Aware of (both C and C++) (con’t)
• static storage class
• scope
• block
• function
• file
• class (C++ only)