3.5 Pure Virtual Functions and File Handling

This section introduces pure virtual functions, dynamic binding, and the fundamentals of file input/output operations using C++. The concept of stream classes is also explained to help manage file operations effectively.

1. Pure Virtual Functions

A pure virtual function is a function declared within a base class that has no definition relative to the base class. It enforces the concept of abstraction and makes a class abstract.

A pure virtual function is declared using the syntax:
```
virtual return_type function_name() = 0;
```
Any class containing at least one pure virtual function is called an abstract class, and objects of such classes cannot be instantiated.

Example: Pure virtual function and dynamic binding.


#include <iostream>
using namespace std;
 
// Abstract base class
class Shape {
public:
    virtual void draw() = 0; // Pure virtual function
};
 
class Circle : public Shape {
public:
    void draw() override {
        cout << "Drawing a Circle" << endl;
    }
};
 
class Rectangle : public Shape {
public:
    void draw() override {
        cout << "Drawing a Rectangle" << endl;
    }
};
 
int main() {
    Shape* shape1 = new Circle();
    Shape* shape2 = new Rectangle();
 
    shape1->draw(); // Output: Drawing a Circle (Dynamic Binding)
    shape2->draw(); // Output: Drawing a Rectangle (Dynamic Binding)
 
    delete shape1;
    delete shape2;
    return 0;
}

2. Dynamic Binding

Dynamic binding ensures that the correct method is called for a derived class object when the object is accessed through a pointer or reference to the base class. This is achieved using virtual functions.

It allows runtime polymorphism.
Ensures that the appropriate overridden function is called for an object.

3. File Input/Output Operations

C++ provides the <fstream> library for file handling. The key classes for file I/O are:

ifstream: For input (reading from a file).
ofstream: For output (writing to a file).
fstream: For both input and output.

File Write Example


#include <iostream>
#include <ofstream> // File stream library
using namespace std;
 
int main() {
    ofstream outFile("example.txt"); // Open file for writing
    if (!outFile) {
        cout << "Error opening file!" << endl;
        return 1;
    }
 
    outFile << "Hello, File Handling in C++!" << endl;
    outFile << "This is a test file." << endl;
 
    outFile.close(); // Close file after writing
    cout << "Data written to file successfully!" << endl;
 
    return 0;
}

The file contains:


Hello, File Handling in C++!
This is a test file.

File Read Example


#include <iostream>
#include <fstream>
using namespace std;
 
int main() {
    ifstream inFile("example.txt"); // Open file for reading
    if (!inFile) {
        cout << "Error opening file!" << endl;
        return 1;
    }
 
    string line;
    while (getline(inFile, line)) { // Read line by line
        cout << line << endl;
    }
 
    inFile.close(); // Close file after reading
    return 0;
}

The file contains:


Hello, File Handling in C++!
This is a test file.

File Append Example


#include <iostream>
#include <fstream>
using namespace std;
 
int main() {
    ofstream outFile("example.txt", ios::app); // Open file in append mode
    if (!outFile) {
        cout << "Error opening file!" << endl;
        return 1;
    }
 
    outFile << "Appending more data to the file." << endl;
 
    outFile.close();
    cout << "Data appended successfully!" << endl;
 
    return 0;
}

The file now contains:


Hello, File Handling in C++!
This is a test file.
Appending more data to the file.

4. Stream Class Hierarchy

C++ provides a hierarchy of stream classes to manage input and output operations:


ios_base
   |
   +--> ios
         |
         +--> istream (input stream)
         |      |
         |      +--> ifstream (file input stream)
         |
         +--> ostream (output stream)
                |
                +--> ofstream (file output stream)
                |
                +--> iostream (input/output stream)
                       |
                       +--> fstream (file input/output stream)

Conclusion

Pure Virtual Functions:
- Declared with = 0 in the base class.
- Makes a class abstract and ensures derived classes implement specific functionality.
Dynamic Binding: Ensures runtime polymorphism through virtual functions.
File Handling:
- ifstream, ofstream, and fstream are key classes for file I/O.
- Files can be opened in modes such as ios::in, ios::out, or ios::app.
Stream Class Hierarchy: Defines how different streams (standard and file-based) interact.