CSC10012
FILE HANDLING IN C++
FIT-HCMUS
Contents
1 Standard file stream class in C++ 2
1.1 std::fstream . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 std::ifstream . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.3 std::ofstream . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2 Essential text file handling functions 3
2.1 open() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.2 close() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.3 is_open() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.4 eof() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.5 getline() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.6 Extraction operator (») . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.7 Insertion Operator («) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3 Essential binary file handling functions 6
3.1 open() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.2 close() and is_open() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.3 read() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.4 tellg() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.5 seekg() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.6 write() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.7 tellp() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3.8 seekp() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
4 Practical examples 8
4.1 Text file handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
4.2 Binary file handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
5 Some notes 12
1
Fundamentals of Programming | CSC10012 Department of Knowledge Engineering
1 Standard file stream class in C++
1.1 std::fstream
• Input/output stream class to operate on files, including reading, writing, and appending.
• Example usage:
#include <fstream> // std::fstream
int main () {
std::fstream fs;
// Open then "test.txt" file to read, write, or append content
fs.open("test.txt", std::fstream::in | std::fstream::out | std::fstream::app);
// Insert the text "Hello World" into the file
fs << "Hello World";
// Close the file
fs.close();
return 0;
}
• Learn more at: std::fstream C++
1.2 std::ifstream
• Stream class to read from files.
• Example usage:
#include <iostream> // std::cout
#include <fstream> // std::ifstream
#include <string> // std::getline
int main() {
std::ifstream fin;
// Open the "test.txt" file to read content
// File only contains the line "Hello World"
fin.open("test.txt");
std::string s = "";
std::getline(fin, s); // Read the line "Hello World" from the file into the string s
// Close the file
fin.close();
Page 2 / 12
Fundamentals of Programming | CSC10012 Department of Knowledge Engineering
std::cout << s; // Print the line "Hello World" to the Console
return 0;
}
• Learn more at: std::ifstream C++
1.3 std::ofstream
• Stream class to write on files.
• Example usage:
#include <fstream> // std::ofstream
int main () {
std::ofstream fout;
// Open the "test.txt" file to write or append
fout.open("test.txt", std::ofstream::out | std::ofstream::app);
// Inset the text "Hello World" into the file
fout << "Hello World";
// close the file
fout.close();
return 0;
}
• Learn more at: std::ofstream C++
2 Essential text file handling functions
2.1 open()
• Opens a file.
• Different stream classes have different ways of calling functions, primarily in the second parameter. Refer to
section 1 for more details.
2.2 close()
• Closes a file.
• Example:
f.close();
Page 3 / 12
Fundamentals of Programming | CSC10012 Department of Knowledge Engineering
2.3 is_open()
• Checks if a file is open.
• Returns true if a file is opened sucessfully, false otherwise.
• Example:
if (!fin.is_open()) {
std::cout << "Error opening file!";
return 0;
}
2.4 eof()
• Checks if eofbit is set.
• Returns true if the stream’s eofbit error state flag is set (which signals that the End-of-File has been reached
by the last input operation), false otherwise.
• Example:
while (!fin.eof()) { // Loop until the end-of-file indicator is reached
std::getline(fin, s);
}
2.5 getline()
• Reads characters from an input stream and places them into a string (std::string).
• To use this function, you must include the <string> header file.
• The following are ways to use the function, assuming the data line to be read is "Name;Age;BirthYear\n":
1. Read an entire line from the file.
– Example: std::getline(fin, s);
– After executing this command, the entire data of the line in the file will be read into s, and the
newline character (\n) will be removed.
– Result: s = "Name;Age;BirthYear".
2. Read until a delimiter is encountered.
– Example: std::getline(fin, s, ’;’);
– After executing this command, s will receive information from the beginning of the line until the
delimiter ; is met.
– Result: s = "Name".
Page 4 / 12
Fundamentals of Programming | CSC10012 Department of Knowledge Engineering
2.6 Extraction operator (»)
• Extracts characters from an input stream (in this scenario, it is a file stream).
• This operator is used similarly to std::cin >>.
• The extraction stops if any of the following conditions is met:
– A whitespace character (a space ’ ’, tab ’\t’, newline ’\n’...) is found. The whitespace character is
not extracted.
– End of file occurs in the input sequence (this also sets eofbit).
• Example: Reading a 1D array from a file "in.txt" with the following content:
5
1 3 5 7 -1
You only need to use the extraction operator without using std::getline.
...
int arr[100];
int n = 0;
std::ifstream fin("in.txt"); // Open the file to read content
fin >> n; // Read the number of elements of the array
for (int i = 0; i < n; i++)
fin >> arr[i]; // Read each element
fin.close();
...
• If the file content does not include the number of elements but only the array data (e.g., 1 3 5 7 -1), we
can use a while loop to read the file content.
...
int arr[100];
int n = 0; // In this case, n must be initialized to 0.
std::ifstream fin("in.txt");
while (fin >> arr[n])
n++;
fin.close();
...
Note: Avoid combining n++ with ifs >> arr[n]. If the file content ends with a whitespace or newline
character, the combined operation would increment n prematurely, leading to the last element being garbage.
Page 5 / 12
Fundamentals of Programming | CSC10012 Department of Knowledge Engineering
2.7 Insertion Operator («)
• Inserts values (e.g. single character, character sequence...) into an output stream (in this scenario, it is a file
stream).
• This operator is used similarly to std::cout <<.
• Example: Square each element of the array read above and write the results to the file "out.txt").
...
std::ofstream fout("out.txt"); // Open the file to write
fout << n; // Write the number of elements of the array
for (int i = 0; i < n; i++)
fout << arr[i] * arr[i] << " "; // Write square of each element
fout.close();
...
3 Essential binary file handling functions
3.1 open()
• Opens a file and associates it with the stream.
• Example:
std::ifstream fin;
fin.open("data.bin", std::ifstream::binary);
3.2 close() and is_open()
• These two functions are used in the same way for text file handling.
3.3 read()
• Reads/extracts blocks of characters.
• Example: Given a binary file named "data.bin", read the first 4 bytes as the array size. Then, allocate
memory and read the remaining bytes into the array.
...
std::ifstream fin;
fin.open("data.bin", std::ifstream::binary);
int n = 0;
fin.read((char*)&n, (int)sizeof(int));
int* arr = new int [n];
Page 6 / 12
Fundamentals of Programming | CSC10012 Department of Knowledge Engineering
fin.read((char*)arr, n*sizeof(int));
fin.close();
...
3.4 tellg()
• Returns the input position indicator.
• Example: Use the file above.
...
std::ifstream fin;
fin.open("data.bin", std::ifstream::binary);
int n = 0;
fin.read((char*)&n, (int)sizeof(int));
std::cout << fin.tellg();
// The console output is 4
...
3.5 seekg()
• Sets the input position indicator.
• Example: Consider a binary file named "data.bin" that solely consists of an integer array. The number of
elements within this array is not explicitly provided.
...
std::ifstream fin;
fin.open("data.bin", std::ifstream::binary);
int n = 0;
fin.seekg(0, std::ifstream::end); // Set the position indicator to the end of file
n = fin.tellg() / sizeof(int); // n now stores the total number of elements in the array
fin.seekg(0, std::ifstream::beg); // Set the position indicator to the beginning of file
...
3.6 write()
• Writes/inserts blocks of characters.
• Example:
...
int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
std::ofstream fout("data.bin", std::ofstream::binary);
Page 7 / 12
Fundamentals of Programming | CSC10012 Department of Knowledge Engineering
fout.write((char*)arr, (int)sizeof(arr));
fout.close();
...
3.7 tellp()
• Returns the output position indicator.
• Example:
...
int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
std::ofstream fout("data.bin", std::ofstream::binary);
fout.write((char*)arr, (int)sizeof(arr));
std::cout << fout.tellp();
// The console output is 40
fout.close();
...
3.8 seekp()
• Sets the output position indicator.
• Example:
...
int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
std::ofstream fout("data.bin", std::ofstream::binary);
fout.write((char*)arr, (int)sizeof(arr));
// Modify the final element of the array to -1
fout.seekp(-(int)sizeof(int), ofstream::end);
int value = -1;
fout.write((char*)&value, (int)sizeof(int));
fout.close();
...
4 Practical examples
4.1 Text file handling
Problem: Read the data from the file named "data.txt" and store it. The file contains the following information:
Page 8 / 12
Fundamentals of Programming | CSC10012 Department of Knowledge Engineering
Name;Math;Literature
Hoa;9;7
Loan;8;8
Hung;7;8
Thanh;10;9.5
Next, save the student’s name and the total score of their two subjects to a file named "result.txt". The data
should be formatted as follows:
Name;TotalScore
Hoa;16
Loan;16
Hung;15
Thanh;19.5
Solution:
#include <iostream>
#include <fstream> // std::ifstream, std::ofstream
#include <string> // std::getline, std::stof
#include <vector>
using namespace std;
struct Student {
string name;
float math, literature;
};
int main() {
// PART 1: READ DATA FROM FILE
// Open the "data.txt" file to read content
ifstream fin;
fin.open("data.txt");
// Quit if file open fails
if (!fin.is_open()) {
cout << "Error opening file!";
return 0;
}
// Ignore the line "Name;Math;Literature"
string ignore_line = "";
getline(fin, ignore_line);
// Declare variables
vector<Student> list_student;
Student temp_student;
string name = "";
Page 9 / 12
Fundamentals of Programming | CSC10012 Department of Knowledge Engineering
string math = "";
string literature = "";
// Keep reading until the end of the file is reached or a read operation fails
while (getline(fin, name, ’;’)) {
// The name content is read first to avoid duplicate information
// when there is an empty line at the end of the file
// Read others from the file into temporary variables
getline(fin, math, ’;’);
getline(fin, literature, ’\n’);
// Assign data from the temporary variables to the Student struct
temp_student.name = name;
temp_student.math = stof(math); // Convert Math score from string to float
temp_student.literature = stof(literature); // Convert Literature score from string to float
// Push the read student data into a vector of students
list_student.push_back(temp_student);
}
// Close the file
fin.close();
//------------------------------------------------------------
// PART 2: SAVE DATA TO FILE
// Open file to save data
ofstream fout;
fout.open("result.txt");
// Quit if file open fails
if (!fout.is_open()) {
cout << "Error opening file!";
return 0;
}
// Save data to the file
fout << "Name;TotalScore\n";
for (int i = 0; i < list_student.size(); i++) {
fout << list_student[i].name << ";";
fout << list_student[i].math + list_student[i].literature << "\n";
}
// Close the file
fout.close();
return 0;
}
Page 10 / 12
Fundamentals of Programming | CSC10012 Department of Knowledge Engineering
4.2 Binary file handling
Problem: Read student records from the binary file "data.bin". Each 28-byte record contains a fixed-width field
structure: 9-byte ID, 9-byte last name, 10-byte first name. Extract records with IDs matching the 2024 class prefix
"2412" and save them to a binary file named "result.bin".
Solution:
#include <iostream>
#include <fstream>
#include <cstring>
using namespace std;
struct Student {
char id[9];
char lastName[9];
char firstName[10];
};
int main() {
// PART 1: READ DATA FROM FILE
ifstream fin("data.bin", ifstream::binary);
// Find the number of student records
fin.seekg(0, ifstream::end);
int n = fin.tellg() / 28;
fin.seekg(0, ifstream::beg);
// Dynamically allocate an array for storing student records
Student* list = new Student[n];
// Read n student records
for (int i = 0; i < n; i++) {
fin.read((char*)&list[i].id, 9);
fin.read((char*)&list[i].lastName, 9);
fin.read((char*)&list[i].firstName, 10);
}
// We can use fin.read((char*)list, n*sizeof(Student)); in this case.
// But it’s not guaranteed for other data structures due to potential alignment issues.
// Close the file
fin.close();
//------------------------------------------------------------
// PART 2: SAVE DATA TO FILE
ofstream fout("result.bin", ofstream::binary);
Page 11 / 12
Fundamentals of Programming | CSC10012 Department of Knowledge Engineering
// Extract and save records to file
for (int i = 0; i < n; i++)
if (strncmp(list[i].id, "2412", 4) == 0) {
fout.write((char*)&list[i].id, 9);
fout.write((char*)&list[i].lastName, 9);
fout.write((char*)&list[i].firstName, 10);
// Or fout.write((char*)&list[i], (int)sizeof(Student));
}
// Close the file
fout.close();
// Deallocate the dynamically allocated array
delete[] list;
return 0;
}
5 Some notes
1. When opening a file, it is MANDATORY to close the file.
2. When opening a file for writing (using std::ofstream::out), there are two possible scenarios:
(a) The file does not exist: A new file is created, and the new content is written to it.
(b) The file already exists: The existing content in the file is completely overwritten, and the new content is
written to it.
3. To append data to an existing file, use std::ofstream::app.
4. Position the file pointer to the beginning (seekg(0, ifstream::beg)) or end (seekg(0, ifstream::end)).
5. Seek within a binary file using positive offsets from the beginning or negative offsets from the end.
THE END
Page 12 / 12
