Sequential Input and Output Operations in C++

Sequential input and output operations in C++ involve processing data in a file in the order in which it is stored. These operations are straightforward and suited for applications where the data is read or written linearly.

C++ provides classes and functions for sequential I/O through the <fstream> library. The most commonly used classes are:

• ifstream: For input (reading data from files).
• ofstream: For output (writing data to files).
• fstream: For both input and output operations.

Basic Workflow of Sequential I/O

1. Input Operations:

   • Open a file for reading using ifstream.
   • Read data sequentially until the end of the file.
   • Close the file after reading.

2. Output Operations:

   • Open a file for writing using ofstream.
   • Write data sequentially to the file.
   • Close the file after writing.
     
     

Example: Sequential Output Operation

Writing data sequentially to a file.

Example: Sequential Input Operation

Reading data sequentially from a file.

Program:

#include <iostream>

#include <fstream>

#include <string>

using namespace std;

int main() {

    ifstream infile("example.txt");

    if (!infile) {

        cout << "Error opening file for reading!" << endl;

        return 1;

    }

    string line;

    // Sequentially reading data from the file

    while (getline(infile, line)) {

        cout << line << endl; // Print each line

    }

    infile.close();

    return 0;

}

File Pointers and Their Manipulations in C++

In C++, file pointers are used to manage the position of the reading or writing cursor within a file. These pointers allow precise control over where data is read from or written to, making file handling efficient and flexible.

Types of File Pointers

1. Input File Pointer (get pointer)
   Used for reading from a file. It determines where the next data will be read.

2. Output File Pointer (put pointer)
   Used for writing to a file. It determines where the next data will be written.

File Pointer Manipulation Functions

C++ provides several member functions for manipulating file pointers. These are:

Function	Purpose
seekg(offset, dir)	Moves the get pointer (read) to a specific location in the file.
seekp(offset, dir)	Moves the put pointer (write) to a specific location in the file.
tellg()	Returns the current position of the get pointer.
tellp()	Returns the current position of the put pointer.
ios::beg	Beginning of the file (used with seekg or seekp).
ios::cur	Current position in the file (used with seekg or seekp).
ios::end	End of the file (used with seekg or seekp).

How to Manipulate File Pointers

1. Moving the get Pointer

The seekg() function moves the input file pointer to a specific position.

Syntax:

file.seekg(offset, direction);

offset: Number of bytes to move.

direction: Position relative to which the movement occurs (ios::beg, ios::cur, or ios::end).

2. Moving the put Pointer

The seekp() function moves the output file pointer to a specific position.

Syntax:
file.seekp(offset, direction);

3. Getting the Current Pointer Position

• tellg() gives the current position of the get pointer.
• tellp() gives the current position of the put pointer.
  
  Example: File Pointer Manipulation

#include <iostream>

#include <fstream>

using namespace std;

int main() {

    fstream file;

    // Open a file in read/write mode

    file.open("example.txt", ios::in | ios::out | ios::trunc);

    if (!file) {

        cout << "Error opening file!" << endl;

        return 1;

    }

    // Write some data to the file

    file << "ABCDEFGH";

    // Move the put pointer to the beginning

    file.seekp(0, ios::beg);

    // Overwrite the first character

    file << 'Z';

    // Move the get pointer to the 4th character

    file.seekg(3, ios::beg);

    // Read the 4th character

    char ch;

    file.get(ch);

    cout << "Character at 4th position: " << ch << endl;

    // Display the current positions of get and put pointers

    cout << "Get pointer position: " << file.tellg() << endl;

    cout << "Put pointer position: " << file.tellp() << endl;

    file.close();

    return 0;

}

Example: 

Key Points

1. Default Behavior of Pointers:

   • When a file is opened in read mode, the get pointer is set to the beginning of the file.
   • When a file is opened in write mode, the put pointer is set to the beginning (or the end if in append mode).

2. Using seekg and seekp:

   • seekg is used for positioning the input pointer (reading).
   • seekp is used for positioning the output pointer (writing).

3. Offsets and Directions:
   The offset parameter specifies the number of bytes to move. The direction specifies the starting point:

   • ios::beg: Beginning of the file.
   • ios::cur: Current position in the file.
   • ios::end: End of the file.

Example: Random Access with File Pointers

Random access is achieved by directly moving the file pointers to the required position.

#include <iostream>

#include <fstream>

using namespace std;

int main() {

    fstream file("data.bin", ios::out | ios::in | ios::binary | ios::trunc);

    if (!file) {

        cout << "Error opening file!" << endl;

        return 1;

    }

    // Write integers to the binary file

    for (int i = 1; i <= 5; i++) {

        file.write((char*)&i, sizeof(i));

    }

    // Move to the 3rd integer (2nd index, as indexing starts from 0)

    file.seekg(2 * sizeof(int), ios::beg);

    // Read and display the 3rd integer

    int num;

    file.read((char*)&num, sizeof(num));

    cout << "The 3rd integer is: " << num << endl;

    // Update the 3rd integer to 10

    num = 10;

    file.seekp(2 * sizeof(int), ios::beg);

    file.write((char*)&num, sizeof(num));

    // Verify the update

    file.seekg(0, ios::beg); // Reset to beginning

    cout << "Updated file contents:" << endl;

    while (file.read((char*)&num, sizeof(num))) {

        cout << num << " ";

    }

    cout << endl;

    file.close();

    return 0;

}

Summary

• File pointers provide flexibility to read/write from specific positions in a file.
• Use seekg and seekp for moving file pointers and tellg/tellp to get their positions.
• These functions are vital for random access in large files, enabling efficient data management.

File Modes

Files can be opened in various modes using flags (e.g., ios::in, ios::out, etc.):

Example:

 Detecting End-of-File (EOF)

The eof() function is used to check if the end of the file has been reached during a read operation.

Example:

#include <iostream>

#include <fstream>

using namespace std;

int main() 

{

std::ifstream file("example.txt");

std::string line;

while (!file.eof()) {

    std::getline(file, line);

    std::cout << line << std::endl;

}

file.close();

    return 0;

}

Output: 

 Working with Files

1. Include the <fstream> Library
   To use file handling features, include the <fstream> library:

Checking if a File is Open:

The is_open() method checks whether the file was successfully opened.

Files and Streams in C++

In C++, files and streams are essential concepts used for input and output operations. They allow a program to interact with data stored in external files and handle input and output from the user or other devices.

Files

A file is a collection of data stored in secondary storage (e.g., hard drive) that can be read or written by a program. Files can be categorized into:

1. Text Files: Store data in human-readable characters.
2. Binary Files: Store data in a format readable only by computers, which is more compact and faster to process.

Virtual functions and Pure virtual functions 

Virtual functions and pure virtual functions are key components of polymorphism, enabling runtime flexibility in class hierarchies. Here’s a detailed look at each, including their differences, purposes, and how they’re used in object-oriented programming.

Virtual Functions

A virtual function is a function defined in a base class that can be overridden by derived classes. When a function is declared as virtual, it tells the compiler to use dynamic binding (or late binding) for that function. This means that the function to be executed is determined at runtime based on the actual type of the object, not the type of the pointer/reference used to call the function.

Characteristics

• Declared in Base Class: Defined with the virtual keyword in the base class.
• Overridable: Derived classes can override this function to provide specific implementations.
• Dynamic Binding: Allows calling the derived class’s overridden function through a base class pointer/reference at runtime.

Purpose

Virtual functions enable polymorphic behavior, where a base class pointer can call functions of derived classes. This allows flexible and extensible code by providing a common interface that different subclasses can implement differently.

Example of Virtual Function

 Static class members

 Static class members in C++ refer to class-level variables or functions that are shared among all instances of the class, rather than being specific to each object. Static members are useful when you want to maintain a single shared state or behavior across all instances of a class.

1. Static Member Variables

A static member variable is shared across all instances of a class. Instead of each object having its own copy, only one copy of a static variable exists, regardless of the number of objects created. Static member variables are useful for maintaining information that is common to all instances, such as a counter to track how many objects have been created.

• Declaration: Declared within the class using the static keyword.
• Initialization: Initialized outside the class definition, typically in the global scope. This ensures that only one instance of the static variable exists.
• Access: Accessed using either an object of the class or by the class name itself.

2. Static Member Functions

A static member function can access only static variables and other static functions within the class. It does not operate on specific instances and thus does not have access to the this pointer, meaning it cannot directly access non-static members of the class.

• Declaration: Declared using the static keyword inside the class.
• Access: Can be called using either an object or directly with the class name.