క్లాసెస్, ఆబ్జెక్ట్స్ & Encapsulation

#include <iostream>
#include <string>

// క్లాస్ డిక్లరేషన్ (బ్లూప్రింట్)
class ElectricCar {
public:
    std::string model;
    int batteryCapacity; // kWh
    int speed;

    void accelerate(int increase) {
        speed += increase;
        std::cout << model << " వేగం " << speed << " km/h కి పెరిగింది!\n";
    }
}; // ⚠️ క్లాస్ చివర సెమికోలన్ (;) తప్పనిసరి!

int main() {
    // ఆబ్జెక్ట్‌ల సృష్టి (Instances in RAM)
    ElectricCar car1;
    car1.model = "Tata Nexon EV";
    car1.batteryCapacity = 40;
    car1.speed = 0;

    ElectricCar car2;
    car2.model = "Tesla Model 3";
    car2.batteryCapacity = 75;
    car2.speed = 0;

    std::cout << "car1 మోడల్: " << car1.model << " (RAM అడ్రస్: " << &car1 << ")\n";
    std::cout << "car2 మోడల్: " << car2.model << " (RAM అడ్రస్: " << &car2 << ")\n";

    car1.accelerate(40);
    car2.accelerate(80);
    return 0;
}

#include <iostream>
#include <string>

class BankVault {
private:
    double totalCash; // ప్రైవేట్ - బయట వారు నేరుగా మార్చలేరు!

public:
    std::string branchName; // పబ్లిక్ - అందరూ చూడవచ్చు

    void deposit(double amount) {
        if (amount > 0) {
            totalCash += amount;
            std::cout << "₹ " << amount << " జమ చేయబడింది.\n";
        }
    }

    void showBalance() {
        std::cout << branchName << " మొత్తం నగదు: ₹ " << totalCash << "\n";
    }
};

int main() {
    BankVault vault;
    vault.branchName = "Hyderabad Main Branch"; // సవ్యమైనది (public)

    // vault.totalCash = 100000000; // ❌ కంపైలర్ ఎర్రర్! 'totalCash' is private!
    vault.deposit(50000);          // సవ్యమైనది! పబ్లిక్ మెథడ్ ద్వారా మాత్రమే డిపాజిట్ సాధ్యం
    vault.showBalance();
    return 0;
}

#include <iostream>
#include <string>

class Employee {
private:
    std::string empName;
    double monthlySalary;

public:
    // Getter ఫంక్షన్ (Read-Only)
    std::string getName() const {
        return empName;
    }

    double getSalary() const {
        return monthlySalary;
    }

    // Setter ఫంక్షన్ విత్ బిజినెస్ వాలిడేషన్
    void setName(const std::string& name) {
        if (!name.empty()) {
            empName = name;
        }
    }

    void setSalary(double salary) {
        if (salary >= 15000.0) { // కనీస వేతన రూల్
            monthlySalary = salary;
        } else {
            std::cout << "⚠️ హెచ్చరిక: వేతనం కనీసం ₹ 15,000 ఉండాలి! తిరస్కరించబడింది.\n";
        }
    }
};

int main() {
    Employee emp;
    emp.setName("Suresh Raina");
    emp.setSalary(50000.0);

    std::cout << "ఉద్యోగి: " << emp.getName() << " | జీతం: ₹ " << emp.getSalary() << "\n";

    emp.setSalary(-500); // వాలిడేషన్ ఫెయిల్ అవుతుంది, డేటా కరప్ట్ కాదు!
    return 0;
}

#include <iostream>

class OrderBuilder {
private:
    int itemsCount = 0;
    double totalPrice = 0.0;

public:
    // Method Chaining కొరకు Reference to *this రిటర్న్ చేస్తున్నాం
    OrderBuilder& addItem(double price) {
        this->itemsCount++; // this-> ద్వారా మెంబర్ వేరియబుల్ యాక్సెస్
        this->totalPrice += price;
        return *this; // ప్రస్తుత ఆబ్జెక్ట్ రిఫరెన్స్ రిటర్న్
    }

    OrderBuilder& applyDiscount(double discountPercentage) {
        this->totalPrice -= (this->totalPrice * (discountPercentage / 100.0));
        return *this;
    }

    void printSummary() const {
        std::cout << "ఆర్డర్ సారాంశం: " << this->itemsCount << " వస్తువులు | మొత్తం బిల్: ₹ " << this->totalPrice << "\n";
        std::cout << "ఆబ్జెక్ట్ మెమరీ అడ్రస్ (this): " << this << "\n";
    }
};

int main() {
    OrderBuilder order;
    // ఫ్లూయెంట్ మెథడ్ చైనింగ్ డెమో!
    order.addItem(1200.0)
         .addItem(800.0)
         .addItem(500.0)
         .applyDiscount(10.0)
         .printSummary();

    return 0;
}

#include <iostream>

class SensorMonitor {
private:
    double temperature;
    mutable int accessCounter = 0; // mutable: const ఫంక్షన్ లోనూ మార్చవచ్చు!

public:
    void setTemperature(double temp) {
        temperature = temp;
    }

    // const మెంబర్ ఫంక్షన్
    double readTemperature() const {
        accessCounter++; // mutable వేరియబుల్ కాబట్టి మార్చడం అనుమతించబడుతుంది (లాగింగ్ కొరకు)
        // temperature += 1.0; // ❌ కంపైలర్ ఎర్రర్! const ఫంక్షన్ లో మెంబర్లను మార్చలేము!
        return temperature;
    }

    int getAccessCount() const { return accessCounter; }
};

void inspectSensor(const SensorMonitor& sensor) {
    // sensor అనేది const reference, కాబట్టి readTemperature() మాత్రమే కాల్ అవుతుంది
    std::cout << "సెన్సార్ ఉష్ణోగ్రత రీడింగ్: " << sensor.readTemperature() << " °C\n";
}

int main() {
    SensorMonitor sm;
    sm.setTemperature(36.5);
    inspectSensor(sm);
    return 0;
}

#include <iostream>
#include <string>

class UserAccount {
private:
    std::string username;

    // C++17 inline static ద్వారా క్లాస్ లోపలే డైరెక్ట్ ఇనిషియలైజేషన్!
    inline static int totalActiveUsers = 0;

public:
    UserAccount(std::string name) : username(name) {
        totalActiveUsers++;
        std::cout << "  [యూజర్ క్రియేట్ చేయబడ్డాడు]: " << username << "\n";
    }

    ~UserAccount() {
        totalActiveUsers--;
        std::cout << "  [యూజర్ తొలగించబడ్డాడు]: " << username << "\n";
    }

    // Static మెంబర్ ఫంక్షన్
    static int getActiveUserCount() {
        // username = "test"; // ❌ ఎర్రర్! static ఫంక్షన్ లో non-static వేరియబుల్స్ వాడలేము!
        return totalActiveUsers;
    }
};

int main() {
    std::cout << "ప్రారంభ యూజర్ల కౌంట్: " << UserAccount::getActiveUserCount() << "\n";

    UserAccount u1("Chaitanya");
    UserAccount u2("Bhavana");
    std::cout << "ప్రస్తుత యూజర్ల కౌంట్: " << UserAccount::getActiveUserCount() << "\n";

    {
        UserAccount u3("Divya");
        std::cout << "స్కోప్ లోపల యూజర్ల కౌంట్: " << UserAccount::getActiveUserCount() << "\n";
    } // u3 డిస్ట్రక్ట్ అవుతుంది

    std::cout << "స్కోప్ వెలుపల యూజర్ల కౌంట్: " << UserAccount::getActiveUserCount() << "\n";
    return 0;
}

#include <iostream>

class Calculator {
private:
    double lastResult;

public:
    Calculator(); // కన్‌స్ట్రక్టర్ డిక్లరేషన్
    double add(double a, double b); // మెంబర్ ఫంక్షన్ డిక్లరేషన్
    void printHistory() const;
};

// క్లాస్ వెలుపల Scope Resolution Operator (::) తో బాడీ రాయడం:
Calculator::Calculator() : lastResult(0.0) {}

double Calculator::add(double a, double b) {
    lastResult = a + b;
    return lastResult;
}

void Calculator::printHistory() const {
    std::cout << "గతంలో గణించిన తాజా ఫలితం: " << lastResult << "\n";
}

int main() {
    Calculator calc;
    std::cout << "సంకలనం (15 + 25): " << calc.add(15, 25) << "\n";
    calc.printHistory();
    return 0;
}

#include <iostream>

class EmptyClass {};

class StructuredData {
    char a;    // 1 Byte + 3 Bytes Padding
    int b;     // 4 Bytes
    double c;  // 8 Bytes
};

int main() {
    std::cout << "sizeof(EmptyClass):    " << sizeof(EmptyClass) << " Byte (ప్రత్యేక అడ్రస్ కొరకు)\n";
    std::cout << "sizeof(StructuredData): " << sizeof(StructuredData) << " Bytes (విత్ CPU Alignment Padding)\n";
    return 0;
}

#include <iostream>
#include <string>
#include <vector>
#include <iomanip>

class BankAccount {
private:
    std::string accountNumber;
    std::string accountHolder;
    double balance;
    int securityPin;
    std::vector<std::string> passbookEntries;

    // క్లాస్-లెవల్ స్టాటిక్ ఆడిట్ వేరియబుల్స్
    inline static int totalAccountsCreated = 0;
    inline static double totalBankDeposits = 0.0;

public:
    BankAccount(std::string accNo, std::string holder, double initialDeposit, int pin)
        : accountNumber(accNo), accountHolder(holder), balance(initialDeposit), securityPin(pin) {
        totalAccountsCreated++;
        totalBankDeposits += initialDeposit;
        passbookEntries.push_back("ప్రారంభ ఖాతా డిపాజిట్: ₹ " + std::to_string(initialDeposit));
    }

    // Method Chaining డిపాజిట్ ఫంక్షన్
    BankAccount& deposit(double amount) {
        if (amount <= 0) {
            std::cout << "❌ డిపాజిట్ తిరస్కరించబడింది: మొత్తం తప్పనిసరిగా ధనాత్మకంగా ఉండాలి.\n";
            return *this;
        }
        balance += amount;
        totalBankDeposits += amount;
        passbookEntries.push_back("జమ (Deposit): +₹ " + std::to_string(amount));
        std::cout << "✅ [జమ సఫలం] " << accountHolder << " ఖాతాలో ₹ " << amount << " జమ చేయబడింది.\n";
        return *this;
    }

    // సెక్యూర్ విత్‌డ్రాయల్ ఫంక్షన్ (విత్ పిన్ వెరిఫికేషన్ & మినిమమ్ బ్యాలెన్స్ చెక్)
    bool withdraw(double amount, int pin) {
        if (pin != securityPin) {
            std::cout << "🚨 [భద్రతా హెచ్చరిక] తప్పుడు సెక్యూరిటీ పిన్! విత్‌డ్రాయల్ నిలిపివేయబడింది.\n";
            return false;
        }
        const double MIN_BALANCE = 1000.0;
        if (balance - amount < MIN_BALANCE) {
            std::cout << "⚠️ [లావాదేవీ రద్దు] ఖాతాలో కనీస బ్యాలెన్స్ ₹ 1,000 తప్పనిసరి. ప్రస్తుత నిల్వ: ₹ " << balance << "\n";
            return false;
        }

        balance -= amount;
        totalBankDeposits -= amount;
        passbookEntries.push_back("విత్‌డ్రాయల్ (Withdrawal): -₹ " + std::to_string(amount));
        std::cout << "💸 [నగదు ఉపసంహరణ సఫలం] ₹ " << amount << " డ్రా చేయబడింది. మిగిలిన బ్యాలెన్స్: ₹ " << balance << "\n";
        return true;
    }

    // Read-Only const ఫంక్షన్
    void printPassbook() const {
        std::cout << "\n--------------------------------------------------------------\n";
        std::cout << "📖 [అధికారిక పాస్‌బుక్ స్టేట్‌మెంట్ - " << accountHolder << "]\n";
        std::cout << "ఖాతా సంఖ్య: " << accountNumber << " | ప్రస్తుత నిల్వ: ₹ " << std::fixed << std::setprecision(2) << balance << "\n";
        std::cout << "లావాదేవీల రికార్డు:\n";
        for (const auto& entry : passbookEntries) {
            std::cout << "  • " << entry << "\n";
        }
        std::cout << "--------------------------------------------------------------\n";
    }

    // Static క్లాస్ ఆడిట్ రిపోర్ట్
    static void generateBankTurnoverReport() {
        std::cout << "\n==============================================================\n";
        std::cout << "🏦 [GLOBAL CORE BANKING AUDIT & TURNOVER REPORT]\n";
        std::cout << "మొత్తం యాక్టివ్ ఖాతాలు     : " << totalAccountsCreated << "\n";
        std::cout << "మొత్తం బ్యాంక్ డిపాజిట్ నిల్వ: ₹ " << std::fixed << std::setprecision(2) << totalBankDeposits << "\n";
        std::cout << "==============================================================\n";
    }
};

int main() {
    std::cout << "==============================================================\n";
    std::cout << "🏦 [ENTERPRISE CORE BANKING LEDGER SYSTEM RUNNING]\n";
    std::cout << "==============================================================\n";

    BankAccount acc1("ACC_987654321", "రమేష్ వర్మ", 25000.0, 4321);
    BankAccount acc2("ACC_123456789", "సునీత రావు", 50000.0, 9988);

    // Method Chaining ద్వారా వరుస డిపాజిట్లు
    acc1.deposit(10000.0).deposit(5000.0);

    // విత్‌డ్రాయల్ ప్రయత్నాలు
    acc1.withdraw(5000.0, 4321); // సరైన పిన్
    acc1.withdraw(10000.0, 1111); // తప్పుడు పిన్ - సెక్యూరిటీ బ్లాక్!

    acc2.deposit(15000.0);
    acc2.withdraw(60000.0, 9988); // కనీస బ్యాలెన్స్ రూల్ ఫెయిల్

    // స్టేట్‌మెంట్లు ప్రింట్ చేయడం
    acc1.printPassbook();
    acc2.printPassbook();

    // గ్లోబల్ స్టాటిక్ ఆడిట్ రిపోర్ట్
    BankAccount::generateBankTurnoverReport();

    return 0;
}