#include <iostream>
using namespace std;

class Student {
public:
    string name;      // data member
    int roll;         // data member

    void show() {     // member function
        cout << name << " " << roll << endl;
    }
};

int main() {
    Student a, b;           // two objects
    a.name = "Rahim"; a.roll = 101;
    b.name = "Karim"; b.roll = 102;
    a.show();
    b.show();
    return 0;
}
// Output:
// Rahim 101
// Karim 102

Here a and b each have their own name and roll. Changing a.roll does not touch b.roll. এখানে a আর b — দুজনের নিজের নিজের name আর roll আছে। a.roll বদলালে b.roll বদলায় না।

class Account {
private:
    double balance;      // hidden
public:
    void setBalance(double b) { balance = b; }
    double getBalance()       { return balance; }
};

int main() {
    Account acc;
    acc.balance = 5000;        // ERROR! balance is private
    acc.setBalance(5000);      // OK
    cout << acc.getBalance();  // OK, prints 5000
}

class Box {
    int w;
public:
    Box& setW(int w) {
        this->w = w;     // left w = member, right w = parameter
        return *this;    // return the object itself
    }
    void show() { cout << "w = " << w << endl; }
};

int main() {
    Box b;
    b.setW(10).show();   // chaining works because setW returns *this
}
// Output:
// w = 10

class Employee;              // forward declarations
class Project;

class Assignment {           // association class: one (employee, project) pair
public:
    Employee* employee;      // who
    Project*  project;       // on what
    int    hoursPerWeek;     // extra data about the PAIR lives here
    string role;             // e.g., "tester", "lead"
};

class Employee {
public:
    int id;
    string name;
    vector<Assignment*> assignments;   // one employee → many assignments
};

class Project {
public:
    int code;
    string title;
    vector<Assignment*> assignments;   // one project → many assignments
};

class BankAccount {
private:
    double balance;   // hidden data
public:
    BankAccount() { balance = 0; }

    void deposit(double amount) {          // setter-style
        if (amount > 0) balance += amount; // validation!
    }
    bool withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            return true;
        }
        return false;
    }
    double getBalance() { return balance; } // getter
};

int main() {
    BankAccount acc;
    acc.deposit(1000);
    acc.deposit(-500);              // ignored: validation blocks it
    acc.withdraw(300);
    cout << acc.getBalance();       // 700
}
// Output: 700

Nobody can write acc.balance = -999;. The data is safe behind the public functions. কেউ acc.balance = -999; লিখতে পারবে না। Public function-এর পেছনে data নিরাপদ।

class Shape {                    // abstract class
public:
    virtual double area() = 0;   // pure virtual: only "what"
};

class Circle : public Shape {
    double r;
public:
    Circle(double r) { this->r = r; }
    double area() { return 3.1416 * r * r; }   // the "how"
};

int main() {
    // Shape s;        // ERROR: cannot create object of abstract class
    Circle c(2);
    cout << c.area();  // 12.5664
}

#include <iostream>
using namespace std;

class Point {
    int x, y;
public:
    Point() {                    // 1. default constructor
        x = 0; y = 0;
        cout << "Default\n";
    }
    Point(int a, int b) {        // 2. parameterized constructor
        x = a; y = b;
        cout << "Parameterized\n";
    }
    Point(const Point &p) {      // 3. copy constructor
        x = p.x; y = p.y;
        cout << "Copy\n";
    }
    void show() { cout << "(" << x << "," << y << ")\n"; }
};

int main() {
    Point a;          // Default
    Point b(3, 4);    // Parameterized
    Point c = b;      // Copy  (same as Point c(b);)
    c.show();         // (3,4)
}
// Output:
// Default
// Parameterized
// Copy
// (3,4)

class A {
    int id;
public:
    A(int i) { id = i; cout << "C" << id << " "; }
    ~A()     { cout << "D" << id << " "; }
};

int main() {
    A a1(1);
    A a2(2);
    A a3(3);
    return 0;
}
// Output:
// C1 C2 C3 D3 D2 D1

Creation order: 1, 2, 3. Destruction order: 3, 2, 1 — last created, first destroyed. তৈরির order: 1, 2, 3। Destroy-এর order: 3, 2, 1 — যে শেষে তৈরি, সে আগে destroy।

class MyArray {
    int *data;
    int n;
public:
    MyArray(int n) {
        this->n = n;
        data = new int[n];
    }
    // DEEP copy constructor
    MyArray(const MyArray &other) {
        n = other.n;
        data = new int[n];              // new memory!
        for (int i = 0; i < n; i++)
            data[i] = other.data[i];    // copy real values
    }
    ~MyArray() { delete[] data; }
};

int main() {
    MyArray a(5);
    MyArray b = a;   // deep copy: b gets its own memory
}   // both destructors run safely — no double free

class Animal {
public:
    Animal()  { cout << "Animal made\n"; }
    ~Animal() { cout << "Animal gone\n"; }
    void eat() { cout << "eating\n"; }
};

class Dog : public Animal {
public:
    Dog()  { cout << "Dog made\n"; }
    ~Dog() { cout << "Dog gone\n"; }
    void bark() { cout << "woof\n"; }
};

int main() {
    Dog d;
    d.eat();    // inherited from Animal
    d.bark();   // Dog's own
}
// Output:
// Animal made      <- base constructor FIRST
// Dog made
// eating
// woof
// Dog gone         <- derived destructor FIRST
// Animal gone

class A { public: int x; };

// WITHOUT virtual: D gets TWO x's
class B : public A {};
class C : public A {};
class D : public B, public C {};

int main() {
    D d;
    // d.x = 5;      // ERROR: ambiguous (B::x or C::x?)
    d.B::x = 5;      // must pick a path — ugly
}

// WITH virtual: D gets ONE shared x
class B2 : virtual public A {};
class C2 : virtual public A {};
class D2 : public B2, public C2 {};

int main2() {
    D2 d;
    d.x = 5;         // OK now — only one copy of A
    return 0;
}

int    add(int a, int b)       { return a + b; }
double add(double a, double b) { return a + b; }
int    add(int a, int b, int c){ return a + b + c; }

int main() {
    cout << add(2, 3)       << endl;  // 5      (int version)
    cout << add(2.5, 3.5)   << endl;  // 6      (double version)
    cout << add(1, 2, 3)    << endl;  // 6      (3-arg version)
}

class Complex {
public:
    double re, im;
    Complex(double r, double i) : re(r), im(i) {}

    Complex operator+(const Complex &o) {
        return Complex(re + o.re, im + o.im);
    }
};

int main() {
    Complex a(1, 2), b(3, 4);
    Complex c = a + b;               // calls a.operator+(b)
    cout << c.re << "+" << c.im << "i";
}
// Output: 4+6i

class Base {
public:
    void hello()          { cout << "Base hello\n"; }   // non-virtual
    virtual void greet()  { cout << "Base greet\n"; }   // virtual
};

class Derived : public Base {
public:
    void hello()          { cout << "Derived hello\n"; } // hides Base::hello
    void greet() override { cout << "Derived greet\n"; } // overrides
};

int main() {
    Derived d;
    Base *p = &d;      // base pointer → derived object

    p->hello();        // Base hello     (non-virtual: pointer type wins)
    p->greet();        // Derived greet  (virtual: object type wins)

    d.hello();         // Derived hello  (direct call, no pointer)
    d.greet();         // Derived greet
}
// Output:
// Base hello
// Derived greet
// Derived hello
// Derived greet

Memory trick: virtual → look at the object; non-virtual → look at the pointer type. মনে রাখার কৌশল: virtual → object দেখুন; non-virtual → pointer-এর type দেখুন।

class Shape {
public:
    virtual double area() = 0;         // pure virtual
    virtual ~Shape() {}                // virtual destructor!
};

class Circle : public Shape {
    double r;
public:
    Circle(double r) : r(r) {}
    double area() override { return 3.1416 * r * r; }
};

class Rect : public Shape {
    double w, h;
public:
    Rect(double w, double h) : w(w), h(h) {}
    double area() override { return w * h; }
};

int main() {
    Shape *shapes[2] = { new Circle(1), new Rect(2, 3) };
    for (int i = 0; i < 2; i++)
        cout << shapes[i]->area() << endl;  // right area() picked at runtime
    for (int i = 0; i < 2; i++)
        delete shapes[i];   // safe: destructor is virtual
}
// Output:
// 3.1416
// 6

class Counter {
public:
    static int count;              // declaration (shared)
    Counter() { count++; }
    static int get() { return count; }   // no object needed
};
int Counter::count = 0;            // definition (required, outside)

int main() {
    Counter a, b, c;
    cout << Counter::get();        // 3 — one shared count
}
// Output: 3

class Box {
private:
    int secret = 42;
    friend void peek(Box &b);      // friend declaration
};

void peek(Box &b) {                // normal function, not a member
    cout << b.secret;              // allowed! it is a friend
}

int main() {
    Box b;
    peek(b);                       // 42
}

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

template <typename T>
class Pair {
public:
    T first, second;
    Pair(T a, T b) : first(a), second(b) {}
};

int main() {
    cout << maxOf(3, 7) << endl;        // 7    (T = int)
    cout << maxOf(2.5, 1.5) << endl;    // 2.5  (T = double)
    Pair<int> p(1, 2);
    cout << p.first + p.second;         // 3
}

double divide(double a, double b) {
    if (b == 0) throw string("Divide by zero!");
    return a / b;
}

int main() {
    try {
        cout << divide(10, 2) << endl;   // 5
        cout << divide(7, 0)  << endl;   // throws — skips the cout
        cout << "never printed\n";
    }
    catch (string &msg) {
        cout << "Error: " << msg << endl;
    }
    cout << "Program continues\n";
}
// Output:
// 5
// Error: Divide by zero!
// Program continues

#include <vector>
#include <map>
#include <set>

int main() {
    vector<int> v = {3, 1, 3};
    v.push_back(5);                 // v = 3 1 3 5 (duplicates kept)

    set<int> s(v.begin(), v.end()); // s = 1 3 5 (sorted, unique)

    map<string, int> marks;
    marks["math"] = 80;
    marks["cse"]  = 95;
    cout << marks["cse"] << endl;   // 95

    for (int x : s) cout << x << " ";  // 1 3 5
}
// Output:
// 95
// 1 3 5

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

unsigned long long fact = 1;

void factorial(int n) {              // this runs in the worker thread
    for (int i = 2; i <= n; i++)
        fact *= i;
}

int main() {
    thread t(factorial, 5);          // start worker thread, argument 5
    t.join();                        // wait for the worker to finish
    cout << "5! = " << fact << endl;
}
// compile: g++ -std=c++11 fact.cpp -pthread
// Output:
// 5! = 120

String a = "buet";
String b = "buet";                 // same pool object as a
String c = new String("buet");     // NEW object, outside the pool

System.out.println(a == b);        // true  (same pool reference)
System.out.println(a == c);        // false (different objects)
System.out.println(a.equals(c));   // true  (same content "buet")

String s = "BUET";
s.concat(" CSE");                  // makes a new String, but we threw it away!
System.out.println(s);             // BUET   (s did not change)

s = s.concat(" CSE");              // now we keep the new object
System.out.println(s);             // BUET CSE

class Outer {
    int x = 10;

    class Inner {                      // non-static inner class
        void show() { System.out.println(x); }   // can use outer's x
    }

    static class Helper {              // static nested class
        void hi() { System.out.println("hi"); }
    }
}

public class Main {
    public static void main(String[] args) {
        Outer outer = new Outer();               // 1) outer object first
        Outer.Inner in = outer.new Inner();      // 2) special syntax!
        in.show();                               // 10

        Outer.Helper h = new Outer.Helper();     // static: no outer object
        h.hi();                                  // hi
    }
}

@FunctionalInterface
interface Calculator {
    int operate(int a, int b);     // the ONE abstract method
}

public class Main {
    public static void main(String[] args) {
        Calculator add = (a, b) -> a + b;        // lambda = the method body
        Calculator mul = (a, b) -> a * b;

        System.out.println(add.operate(3, 4));   // 7
        System.out.println(mul.operate(3, 4));   // 12
    }
}

// OLD: anonymous inner class (before Java 8)
button.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        System.out.println("Clicked!");
    }
});

// NEW: lambda (Java 8+) — same meaning, one line
button.addActionListener(e -> System.out.println("Clicked!"));

import java.util.*;
import java.util.stream.*;

List<String> words = Arrays.asList("BUET", "CSE", "Admission");

List<Integer> lengths = words.stream()          // 1) open the pipeline
        .map(String::length)                    // 2) each word -> its length
        .collect(Collectors.toList());          // 3) gather into a new list

System.out.println(lengths);                    // [4, 3, 9]