The Last-Nighter Salvation Guide

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

class BankAccount {
private:
    string owner;
    double balance;

public:
    // Parameterized Constructor
    BankAccount(string name, double bal) : owner(name), balance(bal) {}

    void deposit(double amt) {
        if (amt > 0) balance += amt;
    }

    void withdraw(double amt) {
        if (amt <= balance) balance -= amt;
        else cout << "[ERROR] Insufficient funds for " << owner << endl;
    }

    void display() const {
        cout << "Account: " << owner
             << " | Balance: Rs." << balance << endl;
    }
}; // <-- SEMICOLON IS MANDATORY

int main() {
    BankAccount accounts[3] = {
        BankAccount("Alice", 5000),
        BankAccount("Bob",   3000),
        BankAccount("Carol", 7500)
    };

    accounts[0].deposit(1500);
    accounts[1].withdraw(500);
    accounts[2].withdraw(10000); // triggers error

    for (int i = 0; i < 3; i++)
        accounts[i].display();

    return 0;
}

#include <iostream>
using namespace std;

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

public:
    void setData(string n, int r, float m); // declaration only
    void display();
    char getGrade();
};

// Definition OUTSIDE the class — uses :: (scope resolution)
void Student::setData(string n, int r, float m) {
    name = n; rollNo = r; marks = m;
}

void Student::display() {
    cout << "Name: "  << name
         << " | Roll: " << rollNo
         << " | Marks: " << marks
         << " | Grade: " << getGrade() << endl;
}

char Student::getGrade() {
    if (marks >= 90) return 'A';
    if (marks >= 75) return 'B';
    if (marks >= 60) return 'C';
    return 'F';
}

int main() {
    Student s1, s2;
    s1.setData("Dharaksh", 101, 92.5);
    s2.setData("Riya",     102, 74.0);
    s1.display();
    s2.display();
    return 0;
}

#include <iostream>
using namespace std;

class Employee {
private:
    string name;
    int id;
    static int count; // shared by ALL objects — declared here

public:
    Employee(string n, int i) : name(n), id(i) {
        count++;        // increments for every new object
    }

    // 'this' pointer: points to the calling object
    Employee& setName(string n) {
        this->name = n;  // 'this->name' disambiguates from param 'n'
        return *this;    // enables method chaining
    }

    void display() const {
        cout << "ID: " << id << " | Name: " << name << endl;
    }

    // Static function — can only access static members
    static void showCount() {
        cout << "Total Employees: " << count << endl;
    }
};

// Static member MUST be defined outside the class
int Employee::count = 0;

int main() {
    Employee e1("Alice", 1);
    Employee e2("Bob", 2);
    Employee e3("Carol", 3);

    e1.setName("Alicia"); // using this pointer internally
    e1.display();
    e2.display();

    Employee::showCount(); // called via class name, not object
    return 0;
}

#include <iostream>
using namespace std;

class Complex {
private:
    float real, imag;

public:
    // 1. Default Constructor
    Complex() : real(0), imag(0) {
        cout << "Default constructor called\n";
    }

    // 2. Parameterized Constructor
    Complex(float r, float i) : real(r), imag(i) {
        cout << "Parameterized constructor called\n";
    }

    // 3. Copy Constructor
    Complex(const Complex &c) : real(c.real), imag(c.imag) {
        cout << "Copy constructor called\n";
    }

    // Destructor
    ~Complex() {
        cout << "Destructor called for ("
             << real << "+" << imag << "i)\n";
    }

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

int main() {
    Complex c1;             // Default
    Complex c2(3.0, 4.0); // Parameterized
    Complex c3(c2);         // Copy

    cout << "c2: "; c2.display();
    cout << "c3: "; c3.display();
    return 0;
    // Destructors called in REVERSE order of creation: c3, c2, c1
}

#include <iostream>
using namespace std;

class Complex {
public:
    float real, imag;
    Complex(float r = 0, float i = 0) : real(r), imag(i) {}

    // Overload + : returns a NEW Complex object (NOT void)
    Complex operator+(const Complex &c) const {
        return Complex(real + c.real, imag + c.imag);
    }

    // Overload - 
    Complex operator-(const Complex &c) const {
        return Complex(real - c.real, imag - c.imag);
    }

    // Overload == (returns bool)
    bool operator==(const Complex &c) const {
        return (real == c.real && imag == c.imag);
    }

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

int main() {
    Complex a(3, 4), b(1, 2);
    Complex sum  = a + b;
    Complex diff = a - b;

    cout << "Sum:  "; sum.display();
    cout << "Diff: "; diff.display();
    cout << "Equal? " << (a == b ? "Yes" : "No") << endl;
    return 0;
}

#include <iostream>
using namespace std;

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

    // Prefix ++c : no int parameter
    Counter& operator++() {
        ++count; return *this;
    }

    // Postfix c++ : dummy int parameter
    Counter operator++(int) {
        Counter tmp(*this);
        count++; return tmp;
    }

    void show() const { cout << "Count = " << count << endl; }
};

int main() {
    Counter c(5);
    ++c; c.show(); // prefix
    c++; c.show(); // postfix
    return 0;
}

#include <iostream>
using namespace std;

class Box {
private:
    double length, width, height;

public:
    Box(double l, double w, double h)
        : length(l), width(w), height(h) {}

    // Friend function — NOT a member, but can access private data
    friend double getVolume(Box b);

    void display() const {
        cout << "Box(" << length << "x"
             << width << "x" << height << ")" << endl;
    }
};

// Defined outside, but has private access because of 'friend'
double getVolume(Box b) {
    return b.length * b.width * b.height;
}

int main() {
    // --- Static allocation ---
    Box b1(3.0, 4.0, 5.0);
    b1.display();
    cout << "Volume: " << getVolume(b1) << endl;

    // --- Dynamic allocation with new/delete ---
    Box* b2 = new Box(2.0, 2.0, 2.0);
    b2->display();
    cout << "Volume: " << getVolume(*b2) << endl;
    delete b2; // MUST free heap memory

    // --- Dynamic array ---
    int n = 3;
    int* arr = new int[n];
    for (int i = 0; i < n; i++) arr[i] = (i + 1) * 10;
    for (int i = 0; i < n; i++) cout << arr[i] << " ";
    cout << endl;
    delete[] arr; // use delete[] for arrays

    return 0;
}

#include <iostream>
using namespace std;

class Student {
public:
    int rollNo;
    Student(int r = 0) : rollNo(r) {}
};

// virtual inheritance prevents duplicate Student in Result
class Marks : virtual public Student {
public:
    float marks;
    Marks(int r = 0, float m = 0) : Student(r), marks(m) {}
};

class Sports : virtual public Student {
public:
    float sportsScore;
    Sports(int r = 0, float s = 0) : Student(r), sportsScore(s) {}
};

class Result : public Marks, public Sports {
public:
    Result(int r, float m, float s)
        : Student(r), Marks(r, m), Sports(r, s) {}

    void display() {
        cout << "Roll No    : " << rollNo      << endl;
        cout << "Marks      : " << marks       << endl;
        cout << "Sports     : " << sportsScore  << endl;
        cout << "Total      : " << (marks + sportsScore) << endl;
    }
};

int main() {
    Result r(101, 85.5, 9.0);
    r.display();
    return 0;
}

#include <iostream>
using namespace std;

class Shape {
public:
    virtual void area() {          // virtual → runtime dispatch
        cout << "Area of generic shape\n";
    }
    virtual ~Shape() {}            // virtual destructor — ALWAYS add this
};

class Circle : public Shape {
    float r;
public:
    Circle(float r) : r(r) {}
    void area() override {        // 'override' is good practice
        cout << "Circle Area = " << 3.14 * r * r << endl;
    }
};

class Rectangle : public Shape {
    float l, w;
public:
    Rectangle(float l, float w) : l(l), w(w) {}
    void area() override {
        cout << "Rectangle Area = " << l * w << endl;
    }
};

int main() {
    Shape* shapes[2];          // base class POINTERS
    shapes[0] = new Circle(5);
    shapes[1] = new Rectangle(4, 6);

    for (int i = 0; i < 2; i++)
        shapes[i]->area();       // calls DERIVED version at runtime

    for (int i = 0; i < 2; i++)
        delete shapes[i];

    return 0;
}

#include <iostream>
using namespace std;

class Animal {      // Abstract class — cannot instantiate directly
public:
    virtual void sound() = 0;  // pure virtual function
    void breathe() {
        cout << "Breathing...\n";
    }
    virtual ~Animal() {}
};

class Dog : public Animal {
public:
    void sound() override { cout << "Dog says: Woof!\n"; }
};

class Cat : public Animal {
public:
    void sound() override { cout << "Cat says: Meow!\n"; }
};

int main() {
    // Animal a; // ERROR: cannot instantiate abstract class
    Animal* a1 = new Dog();
    Animal* a2 = new Cat();

    a1->sound();
    a1->breathe();
    a2->sound();

    delete a1; delete a2;
    return 0;
}

#include <iostream>
using namespace std;

// ── MULTILEVEL: A → B → C ──
class A {
public:
    void showA() { cout << "Class A\n"; }
};

class B : public A {
public:
    void showB() { cout << "Class B\n"; }
};

class C : public B { // C inherits B which inherits A
public:
    void showC() { cout << "Class C\n"; }
};

// ── HIERARCHICAL: Vehicle → Car, Bike ──
class Vehicle {
public:
    int speed;
    Vehicle(int s) : speed(s) {}
    void show() { cout << "Speed: " << speed << endl; }
};

class Car : public Vehicle {
public:
    int doors;
    Car(int s, int d) : Vehicle(s), doors(d) {}
    void display() { cout << "Car | Doors: " << doors << " | "; show(); }
};

class Bike : public Vehicle {
public:
    Bike(int s) : Vehicle(s) {}
    void display() { cout << "Bike | "; show(); }
};

int main() {
    // Multilevel
    C obj;
    obj.showA(); obj.showB(); obj.showC(); // C has all three
    cout << "---\n";
    // Hierarchical
    Car  car(120, 4);
    Bike bike(80);
    car.display();
    bike.display();
    return 0;
}

#include <iostream>
using namespace std;

template <typename T>
class Calculator {
public:
    T add     (T a, T b) { return a + b; }
    T subtract(T a, T b) { return a - b; }
    T multiply(T a, T b) { return a * b; }

    T divide(T a, T b) {
        if (b == 0) throw runtime_error("Division by zero!");
        return a / b;
    }
};

int main() {
    Calculator<int>    ic;
    Calculator<double> dc;

    cout << "Add (int)    : " << ic.add(10, 5)       << endl;
    cout << "Mul (double) : " << dc.multiply(3.5, 2.0) << endl;
    cout << "Div (double) : " << dc.divide(7.5, 2.5)  << endl;

    try {
        cout << ic.divide(10, 0);   // will throw
    }
    catch (const runtime_error &e) { // specific → FIRST
        cout << "Caught: " << e.what() << endl;
    }
    catch (...) {                     // catch-all → LAST
        cout << "Unknown error!\n";
    }

    return 0;
}

#include <iostream>
using namespace std;

template <typename T>
T largest(T a, T b) {
    return (a > b) ? a : b;
}

template <typename T>
void swapValues(T &a, T &b) {
    T tmp = a; a = b; b = tmp;
}

int main() {
    cout << "Largest int    : " << largest(12, 45)       << endl;
    cout << "Largest double : " << largest(3.14, 2.71)   << endl;
    cout << "Largest char   : " << largest('Z', 'A')       << endl;

    int x = 10, y = 20;
    swapValues(x, y);
    cout << "After swap: x=" << x << " y=" << y << endl;

    return 0;
}

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

int main() {
    vector<int> v = {50, 10, 40, 20, 30};

    v.push_back(60);                 // add to end
    v.insert(v.begin() + 2, 99);   // insert 99 at index 2

    cout << "Before sort: ";
    for (int x : v) cout << x << " ";

    sort(v.begin(), v.end());       // sort ascending

    cout << "\nAfter sort:  ";
    for (int x : v) cout << x << " ";

    v.erase(v.begin() + 1);        // erase element at index 1

    cout << "\nAfter erase: ";
    for (int x : v) cout << x << " ";

    cout << "\nSize: " << v.size() << endl;
    return 0;
}

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

int main() {
    // ---- LIST ----
    list<int> lst = {5, 2, 8, 1, 9};
    lst.push_back(3);
    lst.push_front(0);

    lst.sort();  // member function — std::sort() won't work on list!

    cout << "List (sorted): ";
    for (int x : lst) cout << x << " ";
    cout << endl;

    lst.remove(5);   // remove all occurrences of 5
    cout << "After remove(5): ";
    for (int x : lst) cout << x << " ";
    cout << endl;

    // ---- MAP ----
    map<string, int> scores;
    scores["Alice"] = 95;
    scores["Bob"]   = 88;
    scores["Carol"] = 91;
    scores.insert({"Dave", 78});

    cout << "\nMap (sorted by key):\n";
    for (auto &p : scores)
        cout << "  " << p.first << " -> " << p.second << endl;

    // Check if key exists
    if (scores.find("Bob") != scores.end())
        cout << "Bob's score: " << scores["Bob"] << endl;

    return 0;
}

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

int main() {
    // SET: unique + sorted automatically
    set<int> s = {5, 1, 3, 5, 2, 1}; // duplicates dropped
    cout << "Set: ";
    for (int x : s) cout << x << " ";
    cout << endl;

    // VECTOR ALGORITHMS
    vector<int> v = {3, 1, 4, 1, 5, 9, 2, 6};

    // find
    auto it = find(v.begin(), v.end(), 5);
    if (it != v.end())
        cout << "Found 5 at index: " << (it - v.begin()) << endl;

    // count
    cout << "Count of 1: " << count(v.begin(), v.end(), 1) << endl;

    // reverse
    reverse(v.begin(), v.end());
    cout << "Reversed: ";
    for (int x : v) cout << x << " ";
    cout << endl;

    return 0;
}

#include <iostream>
#include <stack>
#include <queue>
#include <vector>
#include <numeric>   // for accumulate
#include <algorithm>
using namespace std;

int main() {
    // ── STACK (LIFO) ──
    stack<int> st;
    st.push(1); st.push(2); st.push(3);
    cout << "Stack (LIFO): ";
    while (!st.empty()) {
        cout << st.top() << " ";
        st.pop();
    }
    cout << endl;

    // ── QUEUE (FIFO) ──
    queue<int> q;
    q.push(10); q.push(20); q.push(30);
    cout << "Queue (FIFO): ";
    while (!q.empty()) {
        cout << q.front() << " ";
        q.pop();
    }
    cout << endl;

    // ── NUMERIC ALGORITHMS ──
    vector<int> v = {5, 3, 8, 1, 9, 2};

    int sum = accumulate(v.begin(), v.end(), 0);
    auto maxIt = max_element(v.begin(), v.end());
    auto minIt = min_element(v.begin(), v.end());

    cout << "Sum:     " << sum    << endl;
    cout << "Max:     " << *maxIt << endl;
    cout << "Min:     " << *minIt << endl;

    // Sort descending using comparator lambda
    sort(v.begin(), v.end(), [](
        int a, int b){ return a > b; });
    cout << "Sorted desc: ";
    for (int x : v) cout << x << " ";
    cout << endl;

    return 0;
}