# Comprehensive C++ File Handling Notes for Exam Preparation
## Table of Contents
1. [Introduction to File Handling](#introduction-to-file-handling)
2. [Streams in C++](#streams-in-c++)
3. [File Operations](#file-operations)
4. [File Opening Modes](#file-opening-modes)
5. [Text vs Binary Files](#text-vs-binary-files)
6. [File Pointers and Random Access](#file-pointers-and-random-access)
7. [Error Handling](#error-handling)
8. [Practical Examples](#practical-examples)
9. [Common Exam Problems](#common-exam-problems)
---
## Introduction to File Handling
### Why Use Files?
- **Permanent Storage**: Data remains even after program termination
- **Large Data Handling**: Files can store much more data than variables in memory
- **Data Sharing**: Multiple programs can access the same file
- **Efficiency**: Avoids repeatedly entering the same data
### File Handling Basics
- Files are stored on secondary storage devices (hard disks, SSDs)
- C++ treats files as streams of bytes
- Two main types: text files and binary files
### File I/O Steps
1. Include `<fstream>` header
2. Declare file stream objects
3. Open the file (associate with physical file)
4. Perform read/write operations
5. Close the file
---
## Streams in C++
### What is a Stream?
A stream is a sequence of bytes flowing from source to destination. In C++, streams are
represented as objects of specific classes.
### Stream Classes Hierarchy
```
ios (Base class)
├── istream (Input stream)
│ ├── ifstream (Input file stream)
│ └── istream_withassign (e.g., cin)
└── ostream (Output stream)
├── ofstream (Output file stream)
└── ostream_withassign (e.g., cout, cerr, clog)
```
### Important Stream Classes
1. **ifstream**: For reading from files
2. **ofstream**: For writing to files
3. **fstream**: For both reading and writing
### Predefined Stream Objects
- `cin`: Standard input (keyboard)
- `cout`: Standard output (screen)
- `cerr`: Unbuffered error output
- `clog`: Buffered error output
---
## File Operations
### Opening Files
Two ways to open files:
1. **Using Constructor**
```cpp
ofstream outFile("data.txt"); // opens for writing
ifstream inFile("data.txt"); // opens for reading
```
2. **Using open() function**
```cpp
fstream file;
file.open("data.txt", ios::out); // opens for writing
```
### Checking File Open Status
```cpp
if (!file) {
cout << "Error opening file!";
return 1;
}
// OR
if (!file.is_open()) {
cout << "File not opened!";
return 1;
}
```
### Closing Files
Always close files after operations:
```cpp
file.close();
```
### Basic File Operations
| Operation | Function | Example |
|-----------|----------|---------|
| Write | `<<` or `put()` | `file << "Hello";` or `file.put('A');` |
| Read | `>>` or `get()` | `file >> var;` or `ch = file.get();` |
| Read line | `getline()` | `getline(file, str);` |
| Binary write | `write()` | `file.write((char*)&obj, sizeof(obj));` |
| Binary read | `read()` | `file.read((char*)&obj, sizeof(obj));` |
---
## File Opening Modes
| Mode | Description |
|------|-------------|
| `ios::in` | Open for reading (default for ifstream) |
| `ios::out` | Open for writing (default for ofstream) |
| `ios::app` | Append to end of file |
| `ios::ate` | Open and seek to end |
| `ios::trunc` | Truncate file if exists |
| `ios::binary` | Open in binary mode |
| `ios::nocreate` | Open fails if file doesn't exist |
| `ios::noreplace` | Open fails if file exists |
**Combining modes**:
```cpp
file.open("data.txt", ios::out | ios::app | ios::binary);
```
---
## Text vs Binary Files
### Text Files
- Human-readable format
- Stores data as ASCII characters
- Uses `<<` and `>>` operators
- Newline characters are translated (platform-dependent)
### Binary Files
- Stores exact memory representation
- More efficient for large data
- Uses `read()` and `write()` functions
- No character translation occurs
### Comparison
| Aspect | Text File | Binary File |
|--------|-----------|-------------|
| Format | Human-readable | Machine-readable |
| Size | Larger (stores as text) | Smaller (stores raw data) |
| Portability | More portable | May have platform issues |
| Access | Sequential | Random access possible |
| Functions | `<<`, `>>`, `get()`, `put()` | `read()`, `write()` |
---
## File Pointers and Random Access
### File Pointers
Each file has two pointers:
1. **Get pointer**: Current read position (ifstream)
2. **Put pointer**: Current write position (ofstream)
### Pointer Manipulation Functions
| Function | Description |
|----------|-------------|
| `tellg()` | Returns current get pointer position |
| `tellp()` | Returns current put pointer position |
| `seekg(pos)` | Moves get pointer to absolute position |
| `seekp(pos)` | Moves put pointer to absolute position |
| `seekg(offset, dir)` | Moves get pointer relative to dir |
| `seekp(offset, dir)` | Moves put pointer relative to dir |
### Reference Positions
- `ios::beg`: Beginning of file
- `ios::cur`: Current position
- `ios::end`: End of file
**Examples**:
```cpp
file.seekg(10); // Move to 10th byte from start
file.seekg(-5, ios::cur); // Move back 5 bytes
file.seekg(0, ios::end); // Move to end
```
---
## Error Handling
### Error Status Flags
| Flag | Meaning |
|------|---------|
| `goodbit` | No errors |
| `eofbit` | End of file reached |
| `failbit` | Logical error (e.g., wrong type) |
| `badbit` | Read/write error |
| `hardfail` | Fatal error |
### Error Checking Functions
| Function | Returns true when |
|----------|-------------------|
| `good()` | No errors |
| `eof()` | End of file reached |
| `fail()` | `failbit` or `badbit` set |
| `bad()` | `badbit` set |
| `clear()` | Clears error flags |
**Example**:
```cpp
while (file.good()) {
// Read file
}
if (file.eof()) {
cout << "End of file reached";
}
```
---
## Practical Examples
### 1. Writing to Text File
```cpp
#include <fstream>
using namespace std;
int main() {
ofstream out("data.txt");
if (!out) {
cout << "Error opening file";
return 1;
}
out << "Hello World\n";
out << 42 << endl;
out.close();
return 0;
}
```
### 2. Reading from Text File
```cpp
#include <fstream>
#include <iostream>
using namespace std;
int main() {
ifstream in("data.txt");
if (!in) {
cout << "Error opening file";
return 1;
}
string line;
while (getline(in, line)) {
cout << line << endl;
}
in.close();
return 0;
}
```
### 3. Binary File Operations
```cpp
struct Person {
char name[50];
int age;
};
// Writing
Person p = {"John", 25};
ofstream out("person.dat", ios::binary);
out.write((char*)&p, sizeof(p));
out.close();
// Reading
Person p2;
ifstream in("person.dat", ios::binary);
in.read((char*)&p2, sizeof(p2));
cout << p2.name << " " << p2.age;
in.close();
```
---
## Common Exam Problems
### Theory Questions
1. Explain the difference between text and binary files.
2. What are file modes in C++? Explain each.
3. Describe the stream class hierarchy in C++.
4. What are file pointers? How are they manipulated?
5. Explain error handling in file operations.
### Coding Problems
1. Write a program to copy contents of one file to another.
2. Create a program to search for a record in a binary file.
3. Implement a program to append data to an existing file.
4. Write a program that displays a file in reverse order.
5. Create a student record system using file handling.
### Sample Solution (Student Record System)
```cpp
#include <iostream>
#include <fstream>
using namespace std;
class Student {
int roll;
char name[30];
float marks;
public:
void getData() {
cout << "Enter roll, name, marks: ";
cin >> roll >> name >> marks;
}
void display() {
cout << roll << "\t" << name << "\t" << marks << endl;
}
int getRoll() { return roll; }
};
int main() {
fstream file("students.dat", ios::binary | ios::in | ios::out | ios::app);
Student s;
char ch;
do {
s.getData();
file.write((char*)&s, sizeof(s));
cout << "Add more? (y/n): ";
cin >> ch;
} while (ch == 'y' || ch == 'Y');
file.seekg(0); // Rewind to start
cout << "\nStudent Records:\n";
while (file.read((char*)&s, sizeof(s))) {
s.display();
}
file.close();
return 0;
}
```
---
These comprehensive notes cover all essential aspects of C++ file handling for your exam
preparation, combining theoretical concepts with practical examples and common exam
problems.
