/* C Style (Procedural): Data separated from function */
struct StudentC {
    int id;
    float marks;
};
void printStudentC(struct StudentC s) {
    printf("ID: %d, Marks: %.2f\n", s.id, s.marks);
}

/* C++ Style (OOP): Data and functions encapsulated in single unit */
class StudentCPP {
private:
    int id;
    float marks;
public:
    StudentCPP(int i, float m) : id(i), marks(m) {}
    void display() const {
        cout << "ID: " << id << ", Marks: " << marks << endl;
    }
};

// 1. Include header for console I/O
#include <iostream>
#include <iomanip> // For stream formatting manipulators

// 2. Use standard namespace
using namespace std;

// 3. Global constant
const double EXAM_PASS_THRESHOLD = 40.0;

// 4. Main function entry point
int main() {
    string studentName;
    double marks;

    cout << "Enter Student Name: ";
    cin >> studentName;

    cout << "Enter Marks Obtained: ";
    cin >> marks;

    cout << "\n=== Academic Status Evaluation ===" << endl;
    cout << "Student: " << studentName << endl;
    cout << "Score:   " << fixed << setprecision(2) << marks << "%" << endl;
    cout << "Result:  " << ((marks >= EXAM_PASS_THRESHOLD) ? "PASSED" : "REAPPEAR") << endl;

    return 0;
}

#include <iostream>
using namespace std;

// Clean Call by Reference without pointer syntax
void swapNumbers(int &x, int &y) {
    int temp = x;
    x = y;
    y = temp;
}

// Inline Function: Compiler replaces call with actual code inline
inline int cube(int s) {
    return s * s * s;
}

int main() {
    int a = 10, b = 25;
    cout << "Before swap: a = " << a << ", b = " << b << endl;

    swapNumbers(a, b);
    cout << "After swap:  a = " << a << ", b = " << b << endl;

    cout << "Cube of 5:   " << cube(5) << endl;

    // Dynamic Memory Allocation via new and delete
    int *dynVal = new int(500); // Allocates heap memory and initializes
    cout << "Dynamic Heap Value: " << *dynVal << endl;
    delete dynVal; // Deallocates memory

    return 0;
}

#include <iostream>
using namespace std;

class Rectangle {
private:
    double length;
    double width;

public:
    void setDimensions(double l, double w) {
        if (l > 0 && w > 0) {
            length = l;
            width = w;
        }
    }

    double calculateArea() {
        return length * width;
    }
};

int main() {
    Rectangle r1, r2; // Object declarations

    r1.setDimensions(10.0, 5.0);
    r2.setDimensions(8.0, 4.5);

    cout << "Area of Rectangle 1: " << r1.calculateArea() << endl;
    cout << "Area of Rectangle 2: " << r2.calculateArea() << endl;

    return 0;
}

#include <iostream>
using namespace std;

class Employee {
private:
    int empId;
    double basicSalary; // Protected against external tampering

public:
    void initialize(int id, double salary) {
        empId = id;
        basicSalary = salary;
    }

    double getNetSalary() const {
        double hra = basicSalary * 0.20; // 20% HRA
        double da  = basicSalary * 0.10; // 10% DA
        return basicSalary + hra + da;
    }

    void displayPaySlip() const {
        cout << "Employee ID: " << empId << endl;
        cout << "Basic: Rs " << basicSalary << " | Net Salary: Rs " << getNetSalary() << endl;
    }
};

int main() {
    Employee e1;
    e1.initialize(501, 45000.0);
    e1.displayPaySlip();

    // e1.basicSalary = 90000; // COMPILATION ERROR: 'basicSalary' is private!
    return 0;
}

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

class Student {
private:
    int rollNo;
    string name;
    float percentage;

public:
    // Member function defined outside class
    void getData(int r, string n, float p);
    void putData() const;
};

// Definition outside class using Scope Resolution Operator
void Student::getData(int r, string n, float p) {
    rollNo = r;
    name = n;
    percentage = p;
}

void Student::putData() const {
    cout << "Roll: " << rollNo << " | Name: " << name << " | Percentage: " << percentage << "%" << endl;
}

int main() {
    // Array of 3 Student objects
    Student bcaBatch[3];

    bcaBatch[0].getData(101, "Kuldeep", 89.5f);
    bcaBatch[1].getData(102, "Manpreet", 93.0f);
    bcaBatch[2].getData(103, "Gurvinder", 81.0f);

    cout << "=== PTU BCA Class Roster ===" << endl;
    for (int i = 0; i < 3; i++) {
        bcaBatch[i].putData();
    }

    return 0;
}

#include <iostream>
using namespace std;

class ComplexNumber {
private:
    double real;
    double imag;

public:
    // 1. Default Constructor
    ComplexNumber() {
        real = 0.0;
        imag = 0.0;
    }

    // 2. Parameterized Constructor with two arguments
    ComplexNumber(double r, double i) {
        real = r;
        imag = i;
    }

    // 3. Overloaded Constructor with single argument
    ComplexNumber(double val) {
        real = val;
        imag = val;
    }

    void print() const {
        cout << real << " + " << imag << "i" << endl;
    }
};

int main() {
    ComplexNumber c1;                // Invokes default constructor
    ComplexNumber c2(4.5, 2.8);       // Invokes parameterized constructor
    ComplexNumber c3(7.0);             // Invokes single-argument constructor

    cout << "c1: "; c1.print();
    cout << "c2: "; c2.print();
    cout << "c3: "; c3.print();

    return 0;
}

#include <iostream>
using namespace std;

class IntegerArray {
private:
    int *data;
    int size;

public:
    // Parameterized Constructor
    IntegerArray(int s) {
        size = s;
        data = new int[size]; // Dynamic memory allocation
        for (int i = 0; i < size; i++) data[i] = 0;
    }

    // User-defined Copy Constructor (Deep Copy)
    IntegerArray(const IntegerArray &source) {
        size = source.size;
        data = new int[size]; // Allocate fresh memory buffer
        for (int i = 0; i < size; i++) {
            data[i] = source.data[i]; // Copy elements
        }
    }

    void set(int index, int value) { data[index] = value; }
    int  get(int index) const       { return data[index]; }

    // Destructor to free heap memory
    ~IntegerArray() {
        delete[] data;
    }
};

int main() {
    IntegerArray arr1(3);
    arr1.set(0, 99);

    IntegerArray arr2 = arr1; // Invokes Copy Constructor
    arr2.set(0, 500);         // Modifying arr2 does not affect arr1!

    cout << "arr1[0]: " << arr1.get(0) << " (remains 99)" << endl;
    cout << "arr2[0]: " << arr2.get(0) << " (modified to 500)" << endl;

    return 0;
}

#include <iostream>
using namespace std;

class Tracer {
private:
    int id;
public:
    Tracer(int val) : id(val) {
        cout << "Constructing Object #" << id << endl;
    }

    ~Tracer() {
        cout << "Destructing  Object #" << id << endl;
    }
};

int main() {
    cout << "Entering main block..." << endl;
    Tracer t1(1);
    Tracer t2(2);

    {
        cout << "\nEntering inner block..." << endl;
        Tracer t3(3);
        cout << "Exiting inner block..." << endl;
    } // t3 goes out of scope and is destroyed here!

    cout << "\nExiting main block..." << endl;
    return 0;
} // t2, then t1 destroyed here in reverse order

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

// Base Class
class Person {
protected:
    string name;
    int age;

public:
    void setPersonData(string n, int a) {
        name = n;
        age = a;
    }
};

// Public Derived Class
class Student : public Person {
private:
    int rollNo;

public:
    void setStudentData(string n, int a, int r) {
        setPersonData(n, a); // Inherited base member
        rollNo = r;
    }

    void display() const {
        // Protected base members are directly accessible in derived class
        cout << "Name: " << name << " | Age: " << age << " | Roll No: " << rollNo << endl;
    }
};

int main() {
    Student s1;
    s1.setStudentData("Maninder", 20, 105);
    s1.display();

    return 0;
}

#include <iostream>
using namespace std;

// Level 1: Grandparent Base Class
class StudentInfo {
protected:
    int rollNo;
public:
    StudentInfo(int r) : rollNo(r) {}
};

// Level 2: Parent Derived Class
class ExamMarks : public StudentInfo {
protected:
    float sub1, sub2;
public:
    ExamMarks(int r, float m1, float m2) 
        : StudentInfo(r), sub1(m1), sub2(m2) {}
};

// Level 3: Child Derived Class
class FinalReport : public ExamMarks {
public:
    FinalReport(int r, float m1, float m2) 
        : ExamMarks(r, m1, m2) {}

    void displayReportCard() const {
        float total = sub1 + sub2;
        cout << "Roll: " << rollNo << " | Sub1: " << sub1 
             << " | Sub2: " << sub2 << " | Total: " << total << endl;
    }
};

int main() {
    FinalReport rpt(101, 85.0f, 92.0f);
    rpt.displayReportCard();

    return 0;
}

#include <iostream>
using namespace std;

class Student {
protected:
    int rollNo;
public:
    void setRoll(int r) { rollNo = r; }
};

// Virtual inheritance prevents duplicate copies
class AcademicTest : virtual public Student {
protected:
    float theoryScore;
public:
    void setTheory(float s) { theoryScore = s; }
};

class SportsActivity : virtual public Student {
protected:
    float sportsScore;
public:
    void setSports(float s) { sportsScore = s; }
};

class FinalResult : public AcademicTest, public SportsActivity {
public:
    void displayScorecard() const {
        // Unambiguous access to rollNo thanks to virtual inheritance!
        cout << "Roll No: " << rollNo << endl;
        cout << "Theory:  " << theoryScore << endl;
        cout << "Sports:  " << sportsScore << endl;
        cout << "Total:   " << (theoryScore + sportsScore) << endl;
    }
};

int main() {
    FinalResult res;
    res.setRoll(108);
    res.setTheory(78.5f);
    res.setSports(15.0f);
    res.displayScorecard();

    return 0;
}

#include <iostream>
using namespace std;

class Vector2D {
private:
    int x, y;

public:
    Vector2D(int xVal = 0, int yVal = 0) : x(xVal), y(yVal) {}

    // 1. Overload Unary Minus (-v)
    Vector2D operator-() const {
        return Vector2D(-x, -y);
    }

    // 2. Overload Binary Addition (v1 + v2)
    Vector2D operator+(const Vector2D &other) const {
        return Vector2D(x + other.x, y + other.y);
    }

    // 3. Overload Stream Insertion Operator (<<) using friend function
    friend ostream& operator<<(ostream &out, const Vector2D &v) {
        out << "(" << v.x << ", " << v.y << ")";
        return out;
    }
};

int main() {
    Vector2D v1(3, 4);
    Vector2D v2(1, 2);

    Vector2D vSum = v1 + v2; // Equivalent to: v1.operator+(v2)
    Vector2D vNeg = -v1;     // Equivalent to: v1.operator-()

    cout << "v1:      " << v1 << endl;
    cout << "v2:      " << v2 << endl;
    cout << "v1 + v2: " << vSum << endl;
    cout << "-v1:     " << vNeg << endl;

    return 0;
}

#include <iostream>
using namespace std;

class Animal {
public:
    void makeSound() const {
        cout << "Generic Animal sound (Early Binding)" << endl;
    }
};

class Dog : public Animal {
public:
    void makeSound() const {
        cout << "Woof! Woof!" << endl;
    }
};

int main() {
    Dog myDog;
    Animal *ptr = &myDog; // Base class pointer holding Derived class object

    ptr->makeSound(); // PRINTS: "Generic Animal sound" (Calls Animal::makeSound)

    return 0;
}

#include <iostream>
using namespace std;

class GraphicShape {
public:
    // Virtual function enables dynamic binding
    virtual void draw() const {
        cout << "Drawing a generic graphic shape." << endl;
    }

    // Virtual destructor ensures proper cleanup of derived objects
    virtual ~GraphicShape() {}
};

class Circle : public GraphicShape {
public:
    void draw() const override {
        cout << "Drawing Circle: O" << endl;
    }
};

class Square : public GraphicShape {
public:
    void draw() const override {
        cout << "Drawing Square: []" << endl;
    }
};

int main() {
    GraphicShape *shapes[2];
    shapes[0] = new Circle();
    shapes[1] = new Square();

    cout << "--- Runtime Polymorphic Dispatch ---\n";
    for (int i = 0; i < 2; i++) {
        shapes[i]->draw(); // Dynamically dispatches to Circle::draw and Square::draw!
    }

    delete shapes[0];
    delete shapes[1];
    return 0;
}

#include <iostream>
using namespace std;

// Abstract Base Class
class DatabaseConnection {
public:
    // Pure Virtual Functions enforcing contract
    virtual void connect() = 0;
    virtual void disconnect() = 0;

    virtual ~DatabaseConnection() {}
};

class MySQLConnection : public DatabaseConnection {
public:
    void connect() override {
        cout << "Connecting to MySQL database server on port 3306..." << endl;
    }
    void disconnect() override {
        cout << "MySQL session closed cleanly." << endl;
    }
};

int main() {
    // DatabaseConnection db; // ERROR: Cannot instantiate abstract class

    DatabaseConnection *conn = new MySQLConnection();
    conn->connect();
    conn->disconnect();

    delete conn;
    return 0;
}

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

int main() {
    ofstream outFile;
    outFile.open("ptu_notes.txt", ios::out);

    if (!outFile.is_open()) {
        cerr << "Error: Failed to create or open file!" << endl;
        return 1;
    }

    outFile << "Punjab Technical University - BCA Curriculum" << endl;
    outFile << "C++ Object Oriented Programming Mastery" << endl;

    outFile.close(); // Flushes stream and closes file handle
    cout << "File created, written, and closed successfully." << endl;

    return 0;
}

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

class StudentProfile {
public:
    int rollNo;
    char name[30];
    float gpa;
};

int main() {
    StudentProfile sWrite = {101, "Amanpreet", 9.4f};

    // 1. Write binary record to disk
    ofstream fOut("students.dat", ios::binary | ios::out);
    fOut.write((char*)&sWrite, sizeof(StudentProfile));
    fOut.close();

    // 2. Read binary record back from disk
    StudentProfile sRead;
    ifstream fIn("students.dat", ios::binary | ios::in);
    fIn.read((char*)&sRead, sizeof(StudentProfile));
    fIn.close();

    cout << "=== Binary Student Profile Read from Disk ===" << endl;
    cout << "Roll: " << sRead.rollNo << " | Name: " << sRead.name << " | GPA: " << sRead.gpa << endl;

    return 0;
}

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

int main() {
    float marks[6];
    float totalMarks = 0.0f;
    float percentage;

    cout << "=== Enter Marks for 6 Subjects (out of 100) ===\n";
    for (int i = 0; i < 6; i++) {
        cout << "Enter marks for Subject " << (i + 1) << ": ";
        cin >> marks[i];
        totalMarks += marks[i];
    }

    percentage = (totalMarks / 600.0f) * 100.0f;

    cout << "\n----------------------------------------\n";
    cout << "Total Marks Obtained: " << totalMarks << " / 600\n";
    cout << fixed << setprecision(2);
    cout << "Overall Percentage:   " << percentage << "%\n";
    cout << "Grade Status:         " << ((percentage >= 40.0f) ? "Passed" : "Reappear") << "\n";
    cout << "----------------------------------------\n";

    return 0;
}

#include <iostream>
using namespace std;

// Function using reference variables as arguments
void swapIntegers(int &x, int &y) {
    int temp = x;
    x = y;
    y = temp;
}

int main() {
    int first, second;

    cout << "Enter two integers: ";
    cin >> first >> second;

    cout << "\nBefore Swapping: first = " << first << ", second = " << second << endl;

    swapIntegers(first, second);

    cout << "After Swapping:  first = " << first << ", second = " << second << endl;

    return 0;
}

#include <iostream>
using namespace std;

// Function returning the maximum of three numbers
double findLargest(double a, double b, double c) {
    if (a >= b && a >= c) {
        return a;
    } else if (b >= a && b >= c) {
        return b;
    } else {
        return c;
    }
}

int main() {
    double n1, n2, n3;
    cout << "Enter three numbers: ";
    cin >> n1 >> n2 >> n3;

    double largest = findLargest(n1, n2, n3);
    cout << "The largest number among (" << n1 << ", " << n2 << ", " << n3 << ") is: " << largest << endl;

    return 0;
}

#include <iostream>
using namespace std;

int main() {
    int num;
    unsigned long long factorial = 1;

    cout << "Enter a non-negative integer: ";
    cin >> num;

    if (num < 0) {
        cout << "Error! Factorial of a negative number does not exist." << endl;
    } else {
        for (int i = 1; i <= num; i++) {
            factorial *= i;
        }
        cout << "Factorial of " << num << " = " << factorial << endl;
    }

    return 0;
}

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

class BankAccount {
private:
    string depositorName;
    long long accountNumber;
    double withdrawalAmount;
    double balanceAmount;

public:
    // a) Assign initial values
    void assignInitialValues(string name, long long accNo, double initialBalance) {
        depositorName = name;
        accountNumber = accNo;
        balanceAmount = initialBalance;
        withdrawalAmount = 0.0;
    }

    // b) Deposit an amount
    void deposit(double amount) {
        if (amount > 0) {
            balanceAmount += amount;
            cout << "Successfully deposited Rs " << amount << endl;
        } else {
            cout << "Invalid deposit amount!\n";
        }
    }

    // c) Withdraw an amount after checking balance
    void withdraw(double amount) {
        if (amount <= balanceAmount) {
            withdrawalAmount = amount;
            balanceAmount -= amount;
            cout << "Successfully withdrew Rs " << amount << endl;
        } else {
            cout << "Transaction Rejected: Insufficient balance! (Available: Rs " 
                 << balanceAmount << ")\n";
        }
    }

    // d) Display name and balance
    void display() const {
        cout << "-------------------------------------\n";
        cout << "Account Number:  " << accountNumber << endl;
        cout << "Depositor Name:  " << depositorName << endl;
        cout << "Current Balance: Rs " << balanceAmount << endl;
        cout << "-------------------------------------\n";
    }
};

int main() {
    BankAccount acc;
    acc.assignInitialValues("Karanveer Singh", 10023456789LL, 25000.0);

    acc.display();
    acc.deposit(7500.0);
    acc.withdraw(12000.0);
    acc.withdraw(50000.0); // Demonstrates balance check
    acc.display();

    return 0;
}

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

class BankAccount {
private:
    string name;
    int accNo;
    double balance;

public:
    void input() {
        cout << "Enter Account Number: ";
        cin >> accNo;
        cout << "Enter Depositor Name: ";
        cin >> name;
        cout << "Enter Initial Balance: ";
        cin >> balance;
    }

    int getAccNo() const { return accNo; }

    void display() const {
        cout << "Acc No: " << accNo << " | Name: " << name << " | Balance: Rs " << balance << endl;
    }
};

int main() {
    int n;
    cout << "Enter total number of account holders: ";
    cin >> n;

    // Dynamic array of objects for n holders
    BankAccount *customers = new BankAccount[n];

    for (int i = 0; i < n; i++) {
        cout << "\nEnter details for Customer #" << (i + 1) << ":\n";
        customers[i].input();
    }

    cout << "\n=== Registered Bank Accounts Summary ===\n";
    for (int i = 0; i < n; i++) {
        customers[i].display();
    }

    delete[] customers; // Clean up allocated heap memory
    return 0;
}

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

// 1. Right-Angled Triangle Area
double area(double base, double height) {
    return 0.5 * base * height;
}

// 2. Equilateral Triangle Area (single parameter)
double area(double side) {
    return (sqrt(3.0) / 4.0) * side * side;
}

// 3. Isosceles Triangle Area (distinguished by float type tags or explicit formula)
float area(float equalSide, float base) {
    return (base / 4.0f) * sqrt(4.0f * equalSide * equalSide - base * base);
}

int main() {
    cout << "Area of Right-Angled Triangle (b=6, h=8): " 
         << area(6.0, 8.0) << endl;

    cout << "Area of Equilateral Triangle (side=5):   " 
         << area(5.0) << endl;

    cout << "Area of Isosceles Triangle (a=5, b=6):      " 
         << area(5.0f, 6.0f) << endl;

    return 0;
}

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

class Publication {
protected:
    string title;
    float price;

public:
    void get_data() {
        cout << "Enter Title: ";
        cin.ignore();
        getline(cin, title);
        cout << "Enter Price: Rs ";
        cin >> price;
    }

    void put_data() const {
        cout << "Title: " << title << " | Price: Rs " << price;
    }
};

class Book : public Publication {
private:
    int pageCount;

public:
    void get_data() {
        Publication::get_data();
        cout << "Enter Page Count: ";
        cin >> pageCount;
    }

    void put_data() const {
        Publication::put_data();
        cout << " | Pages: " << pageCount << endl;
    }
};

class Tape : public Publication {
private:
    float playingTime;

public:
    void get_data() {
        Publication::get_data();
        cout << "Enter Playing Time (minutes): ";
        cin >> playingTime;
    }

    void put_data() const {
        Publication::put_data();
        cout << " | Duration: " << playingTime << " mins" << endl;
    }
};

int main() {
    Book b;
    Tape t;

    cout << "=== Enter Book Details ===\n";
    b.get_data();

    cout << "\n=== Enter Audio Tape Details ===\n";
    t.get_data();

    cout << "\n=== Publication Information Summary ===\n";
    b.put_data();
    t.put_data();

    return 0;
}

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

// Base Class: student
class Student {
protected:
    int rollNo;
    string name;

public:
    void getStudent(int r, string n) {
        rollNo = r;
        name = n;
    }
    void putStudent() const {
        cout << "Roll No: " << rollNo << " | Name: " << name << endl;
    }
};

// Intermediate Class: exam inherits student
class Exam : public Student {
protected:
    float marks[5];

public:
    void getMarks(float m[]) {
        for (int i = 0; i < 5; i++) {
            marks[i] = m[i];
        }
    }
};

// Derived Class: result inherits exam
class Result : public Exam {
private:
    float total;
    float avg;

public:
    void calculateAndDisplay() {
        total = 0.0f;
        for (int i = 0; i < 5; i++) {
            total += marks[i];
        }
        avg = total / 5.0f;

        cout << "\n=== PTU BCA Academic Marksheet ===\n";
        putStudent();
        cout << "Marks: ";
        for (int i = 0; i < 5; i++) {
            cout << marks[i] << " ";
        }
        cout << "\nTotal: " << total << " / 500" << endl;
        cout << "Average: " << avg << "%" << endl;
    }
};

int main() {
    Result student1;
    student1.getStudent(2026101, "Harshpreet Singh");

    float m[5] = {88.5f, 92.0f, 79.5f, 85.0f, 91.0f};
    student1.getMarks(m);
    student1.calculateAndDisplay();

    return 0;
}

#include <iostream>
using namespace std;

class Counter {
private:
    int count;

public:
    Counter(int c = 0) : count(c) {}

    // Prefix form (++c): increments first, returns updated object
    Counter operator++() {
        ++count;
        return *this;
    }

    // Postfix form (c++): int dummy parameter distinguishes postfix
    Counter operator++(int) {
        Counter temp = *this;
        count++;
        return temp; // returns value prior to increment
    }

    void display() const {
        cout << "Count: " << count << endl;
    }
};

int main() {
    Counter c1(5);

    cout << "Initial value: "; c1.display();

    ++c1;
    cout << "After Prefix ++c1:  "; c1.display();

    c1++;
    cout << "After Postfix c1++: "; c1.display();

    return 0;
}

#include <iostream>
using namespace std;

class Complex {
private:
    float real;
    float imag;

public:
    Complex(float r = 0.0f, float i = 0.0f) : real(r), imag(i) {}

    // Overloading binary + operator
    Complex operator+(const Complex &c) const {
        return Complex(real + c.real, imag + c.imag);
    }

    void display() const {
        cout << real << " + " << imag << "i" << endl;
    }
};

int main() {
    Complex c1(3.5f, 2.5f);
    Complex c2(1.5f, 4.5f);

    Complex c3 = c1 + c2; // Invokes c1.operator+(c2)

    cout << "c1:       "; c1.display();
    cout << "c2:       "; c2.display();
    cout << "c1 + c2:  "; c3.display();

    return 0;
}

#include <iostream>
using namespace std;

class MediaDevice {
public:
    // Virtual function enables dynamic method dispatch
    virtual void play() const {
        cout << "Playing media on generic device." << endl;
    }

    virtual ~MediaDevice() {}
};

class AudioPlayer : public MediaDevice {
public:
    void play() const override {
        cout << "Playing MP3 Audio track (Stereo Output)" << endl;
    }
};

class VideoPlayer : public MediaDevice {
public:
    void play() const override {
        cout << "Playing MP4 Video (1080p Full HD)" << endl;
    }
};

int main() {
    MediaDevice *devicePtr;

    AudioPlayer audio;
    VideoPlayer video;

    devicePtr = &audio;
    devicePtr->play(); // Dispatches to AudioPlayer::play

    devicePtr = &video;
    devicePtr->play(); // Dispatches to VideoPlayer::play

    return 0;
}

#include <iostream>
using namespace std;

// Abstract Base Class
class Shape {
public:
    // Pure Virtual Function
    virtual double calculateArea() const = 0;
    virtual void   displayShape() const = 0;

    virtual ~Shape() {}
};

class Rectangle : public Shape {
private:
    double width, height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}

    double calculateArea() const override {
        return width * height;
    }
    void displayShape() const override {
        cout << "Rectangle (" << width << "x" << height << ") | Area: " << calculateArea() << endl;
    }
};

int main() {
    Shape *s = new Rectangle(7.0, 4.0);
    s->displayShape();

    delete s;
    return 0;
}

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

int main() {
    // 1. Writing data to file using ofstream
    ofstream outFile("assignment_test.txt");
    if (!outFile) {
        cerr << "Error: Unable to open file for writing!\n";
        return 1;
    }

    outFile << "Punjab Technical University - BCA Practical Assignment\n";
    outFile << "Subject: Object Oriented Programming in C++\n";
    outFile << "Status: File operations executed successfully.\n";
    outFile.close();

    cout << "Data written to file successfully.\n\n";

    // 2. Reading data back from file using ifstream
    ifstream inFile("assignment_test.txt");
    if (!inFile) {
        cerr << "Error: Unable to open file for reading!\n";
        return 1;
    }

    cout << "=== Reading File Contents Line-by-Line ===\n";
    string line;
    while (getline(inFile, line)) {
        cout << line << endl;
    }
    inFile.close();

    return 0;
}