class BankAccount {
private:    // accessible only within the class
    std::string owner;
    double balance;

public:     // accessible from outside
    // Constructor
    BankAccount(const std::string& owner, double initial_balance)
        : owner(owner), balance(initial_balance) {}  // member initializer list
    
    // Getter (const — promises not to modify state)
    double getBalance() const { return balance; }
    std::string getOwner() const { return owner; }
    
    // Methods
    void deposit(double amount) {
        if (amount > 0) balance += amount;
    }
    
    bool withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            return true;
        }
        return false;
    }
};

BankAccount acc("Alice", 1000.0);
acc.deposit(500.0);
std::cout << acc.getBalance();  // 1500.0

class Widget {
    int id;
    std::string name;
    int* data;

public:
    // 1. Default constructor
    Widget() : id(0), name("unnamed"), data(nullptr) {}
    
    // 2. Parameterized constructor
    Widget(int id, const std::string& name)
        : id(id), name(name), data(new int[100]) {}
    
    // 3. Copy constructor
    Widget(const Widget& other)
        : id(other.id), name(other.name), data(new int[100]) {
        std::copy(other.data, other.data + 100, data);
    }
    
    // 4. Move constructor (C++11)
    Widget(Widget&& other) noexcept
        : id(other.id), name(std::move(other.name)), data(other.data) {
        other.data = nullptr;  // leave source in valid state
    }
    
    // 5. Destructor
    ~Widget() {
        delete[] data;  // free resources
    }
};

class Fraction {
public:
    explicit Fraction(int numerator, int denominator = 1)
        : num(numerator), den(denominator) {}
private:
    int num, den;
};

Fraction f1(3);         // OK: direct initialization
Fraction f2 = 3;        // ERROR: implicit conversion blocked by explicit

class Shape {
protected:
    std::string color;
public:
    Shape(const std::string& color) : color(color) {}
    virtual double area() const = 0;       // pure virtual → abstract
    virtual double perimeter() const = 0;  // pure virtual → abstract
    virtual void draw() const {            // virtual — can be overridden
        std::cout << "Drawing " << color << " shape\n";
    }
    virtual ~Shape() = default;            // ALWAYS virtual destructor in base
};

class Circle : public Shape {
    double radius;
public:
    Circle(const std::string& color, double radius)
        : Shape(color), radius(radius) {}
    
    double area() const override { return 3.14159 * radius * radius; }
    double perimeter() const override { return 2 * 3.14159 * radius; }
};

class Rectangle : public Shape {
    double width, height;
public:
    Rectangle(const std::string& color, double w, double h)
        : Shape(color), width(w), height(h) {}
    
    double area() const override { return width * height; }
    double perimeter() const override { return 2 * (width + height); }
};

void printArea(const Shape& shape) {
    std::cout << "Area: " << shape.area() << "\n";  // calls correct derived version
}

Circle c("red", 5.0);
Rectangle r("blue", 4.0, 6.0);
printArea(c);  // Area: 78.5398
printArea(r);  // Area: 24.0

// Works with smart pointers for ownership
std::vector<std::unique_ptr<Shape>> shapes;
shapes.push_back(std::make_unique<Circle>("red", 5.0));
shapes.push_back(std::make_unique<Rectangle>("blue", 4.0, 6.0));

for (const auto& s : shapes) {
    std::cout << s->area() << "\n";  // dynamic dispatch at runtime
}

// Interface pattern — all pure virtual, no data
class Serializable {
public:
    virtual std::string serialize() const = 0;
    virtual void deserialize(const std::string& data) = 0;
    virtual ~Serializable() = default;
};

// A class can implement multiple interfaces
class Stock : public Tradeable, public Serializable {
    std::string symbol;
    double current_price;
public:
    double price() const override { return current_price; }
    std::string ticker() const override { return symbol; }
    std::string serialize() const override { /* ... */ return ""; }
    void deserialize(const std::string& data) override { /* ... */ }
};

class Vector2D {
    double x, y;
public:
    Vector2D(double x = 0, double y = 0) : x(x), y(y) {}
    
    // Arithmetic (member)
    Vector2D operator+(const Vector2D& rhs) const {
        return {x + rhs.x, y + rhs.y};
    }
    Vector2D operator*(double scalar) const {
        return {x * scalar, y * scalar};
    }
    
    // Comparison
    bool operator==(const Vector2D& rhs) const {
        return x == rhs.x && y == rhs.y;
    }
    
    // Subscript
    double& operator[](int i) { return (i == 0) ? x : y; }
    
    // Stream output (friend — non-member with private access)
    friend std::ostream& operator<<(std::ostream& os, const Vector2D& v) {
        return os << "(" << v.x << ", " << v.y << ")";
    }
};

// Non-member (allows 2.0 * vec, not just vec * 2.0)
Vector2D operator*(double scalar, const Vector2D& v) {
    return v * scalar;
}

Vector2D a{1, 2}, b{3, 4};
auto c = a + b;           // (4, 6)
auto d = 2.0 * a;         // (2, 4)
std::cout << c;            // (4, 6)

class Connection {
    static int count;              // shared across all instances
    static const int MAX = 100;   // compile-time constant
    
public:
    Connection() { ++count; }
    ~Connection() { --count; }
    
    static int getCount() { return count; }  // callable without an object
};

int Connection::count = 0;  // must define outside class (once, in a .cpp file)

// Usage
Connection c1, c2;
std::cout << Connection::getCount();  // 2

template <typename Derived>
class Shape {
public:
    double area() const {
        return static_cast<const Derived*>(this)->area_impl();
    }
};

class Circle : public Shape<Circle> {
    double radius;
public:
    Circle(double r) : radius(r) {}
    double area_impl() const { return 3.14159 * radius * radius; }
};