> For the complete documentation index, see [llms.txt](https://nec-license.gitbook.io/books/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://nec-license.gitbook.io/books/3.-programming-language-and-its-applications/3.5-pure-virtual-functions-and-file-handling.md).

# 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:

  ```cpp
  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.

```cpp
#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**

```cpp
#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:

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

***

**File Read Example**

```cpp
#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:

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

***

**File Append Example**

```cpp
#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:

```css
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:

```lua
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.