Classes & Objects: OOP Architectural Foundations

#include <iostream>
#include <string>

class BankAccount {
private:
    // Encapsulated data members: Hidden from unauthorized mutation
    std::string accountNumber;
    double balance;

public:
    // Member function defined INSIDE class (implicitly inline)
    void setAccount(const std::string& acc, double initialDeposit) {
        accountNumber = acc;
        balance = initialDeposit;
    }

    // Member function prototypes: Defined OUTSIDE using scope resolution (::)
    void deposit(double amount);
    bool withdraw(double amount);
    void display() const;
};

// Outside definition using Scope Resolution Operator (::)
void BankAccount::deposit(double amount) {
    if (amount > 0) {
        balance += amount;
    }
}

bool BankAccount::withdraw(double amount) {
    if (amount > 0 && balance >= amount) {
        balance -= amount;
        return true;
    }
    return false;
}

void BankAccount::display() const {
    std::cout << "Account: " << accountNumber 
              << " | Balance: $" << balance << "\n";
}

int main() {
    BankAccount account1;
    account1.setAccount("DEV-9082", 1500.0);
    account1.deposit(350.0);
    account1.withdraw(200.0);
    account1.display();

    // account1.balance = 50000; // COMPILE ERROR: 'balance' is private!
    return 0;
}

#include <iostream>

class Vector2D {
private:
    double x;
    double y;

public:
    // 1. Resolving Name Collisions between parameters and data members
    void setCoordinates(double x, double y) {
        this->x = x; // Disambiguates member x from parameter x
        this->y = y;
    }

    // 2. Method Chaining: Returning *this by reference
    Vector2D& scale(double factor) {
        this->x *= factor;
        this->y *= factor;
        return *this; // Return reference to calling object
    }

    void print() const {
        std::cout << "Vector(" << x << ", " << y << ")\n";
    }
};

int main() {
    Vector2D v;
    v.setCoordinates(2.0, 5.0);

    // Method Chaining via *this reference:
    v.scale(2.0).scale(1.5); 
    v.print(); // Prints: Vector(6, 15)

    return 0;
}

#include <iostream>

class ConnectionPool {
private:
    int connectionId;
    
    // Static data member declaration (Class-wide shared counter)
    static int activeConnections;

public:
    ConnectionPool(int id) : connectionId(id) {
        ++activeConnections; // Increments shared static counter
    }

    ~ConnectionPool() {
        --activeConnections;
    }

    // Static member function: Accessible without an object instance
    static int getActiveCount() {
        // connectionId = 0; // COMPILE ERROR: Cannot access non-static member!
        return activeConnections;
    }
};

// MANDATORY: Definition and initialization in file scope:
int ConnectionPool::activeConnections = 0;

int main() {
    std::cout << "Initial count: " << ConnectionPool::getActiveCount() << "\n"; // 0

    ConnectionPool c1(101);
    ConnectionPool c2(102);

    std::cout << "Active after 2 connections: " 
              << ConnectionPool::getActiveCount() << "\n"; // 2

    return 0;
}

#include <iostream>

class Engine; // Forward declaration

class TelemetryMonitor {
public:
    // Can inspect private members of Engine because it is a friend
    void inspectEngine(const Engine& e);
};

class Engine {
private:
    int rpm{3500};
    double temperature{92.4};

    // 1. Friend Function Declaration
    friend void diagnosticReport(const Engine& e);

    // 2. Friend Class Declaration
    friend class TelemetryMonitor;
};

// Friend function definition (Global function with private access)
void diagnosticReport(const Engine& e) {
    std::cout << "[Diagnostic Report] RPM: " << e.rpm 
              << " | Temp: " << e.temperature << " C\n";
}

void TelemetryMonitor::inspectEngine(const Engine& e) {
    std::cout << "[Telemetry Monitor] Verifying Temp: " << e.temperature << " C\n";
}

int main() {
    Engine v8;
    diagnosticReport(v8);

    TelemetryMonitor monitor;
    monitor.inspectEngine(v8);

    return 0;
}