SRM OODP Unit 5 📘

File handling in C++ is the mechanism used to store data permanently in a secondary storage device (like a hard drive) and retrieve it. It allows C++ programs to communicate with files using input and output streams.

PROGRAM  --->  FILE  --->  STORAGE

#include <iostream>
#include <fstream>
using namespace std;

int main() {
    ofstream file;            // Step 1: Create stream object
    file.open("demo.txt");    // Step 2: Open file
    file << "Hello SRM";      // Step 3: Write to file
    file.close();             // Step 4: Close file
    return 0;
}

A Stream is an abstraction that represents a device on which input and output operations are performed. A stream acts as a flow of data (sequence of bytes) between the executing program and I/O devices.

File opening modes determine how a file will be processed once it is opened. They are defined inside the ios class.

Files are interacted with using the <fstream> library by instantiating stream objects.

#include <iostream>
#include <fstream>
using namespace std;

int main() {
    // WRITING TO A FILE
    ofstream fout;
    fout.open("data.txt");
    fout << "Orygyns Educational Platform";
    fout.close();

    // READING FROM A FILE
    ifstream fin;
    string text;
    fin.open("data.txt");
    
    // Read string from file
    fin >> text; // Reads word by word
    cout << "Data read from file: " << text << endl;
    
    fin.close();
    return 0;
}

The Standard Template Library (STL) is a powerful set of C++ template classes that provide general-purpose predefined classes and functions for implementing highly efficient data structures and algorithms (like arrays, lists, stacks, trees).

STL
 |
 |--- Containers
 |--- Iterators
 |--- Algorithms

Core Components of STL:

• Containers: Objects that store data elements. They manage the memory allocation for these elements. (e.g., Vector, List, Map).
• Algorithms: Procedures that perform operations on containers like searching, sorting, and reversing. (e.g., sort(), find()).
• Iterators: Objects that act like pointers. They are used to step through or iterate over the elements of a container safely.

A vector is a sequence container that represents a dynamic array. Its size can change automatically as elements are added or removed, making it superior to standard arrays.

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> v;
    
    // Inserting elements
    v.push_back(10); 
    v.push_back(20);
    v.push_back(30);
    
    // Accessing elements
    cout << "First element: " << v[0] << endl; // Output: 10
    cout << "Vector size: " << v.size() << endl; // Output: 3
    
    return 0;
}

A list is a sequence container that allows non-contiguous memory allocation. It represents a doubly-linked list, which allows incredibly fast insertions and deletions anywhere within the sequence.

#include <iostream>
#include <list>
using namespace std;

int main() {
    list<int> l;
    
    // Inserting elements
    l.push_back(10);  // Adds to the end
    l.push_back(20);
    l.push_front(5);  // Adds to the beginning
    
    // Iterating through the list
    cout << "List elements: ";
    for(int x : l) {
        cout << x << " ";
    }
    // Output: 5 10 20
    
    return 0;
}

A map is an associative container that stores elements in Key-Value pairs. Keys must be strictly unique, and elements are automatically sorted by the key. It acts like a dictionary.

#include <iostream>
#include <map>
using namespace std;

int main() {
    map<int, string> m;
    
    // Inserting data as Key-Value pairs
    m[1] = "SRM";
    m[2] = "Orygyns";
    m[3] = "C++ Course";
    
    // Accessing via Key
    cout << "Value at key 1: " << m[1] << endl; // Output: SRM
    
    return 0;
}

Knowing when to use a Vector versus a List is a critical concept in C++ STL programming.

UML (Unified Modeling Language) is crucial for visualizing the design of a system. Here is a summary of the diagrams required for SRM OODP.

System Integration Mapping

A fundamental visualization of how the User, System logic, and File/Database integrate in a software architecture.

USER ---> SYSTEM ---> DATABASE