పాలిమార్ఫిజమ్ & Virtual Functions

#include <iostream>

class Vehicle {
public:
    virtual void describe() const {
        std::cout << "  🚗 [Vehicle] సాధారణ రవాణా వాహనం.\n";
    }
};

class SuperCar : public Vehicle {
public:
    int turboHorsepower = 850;
    void describe() const override {
        std::cout << "  🏎️ [SuperCar] టర్బో సూపర్ కార్! అశ్వశక్తి: " << turboHorsepower << " HP!\n";
    }
};

// ❌ ప్రమాదకరమైన ఫంక్షన్: Pass by Value (Object Slicing జరుగుతుంది!)
void inspectByValue(Vehicle v) {
    v.describe(); // కేవలం బేస్ వెర్షన్ మాత్రమే పిలువబడుతుంది!
}

// ✅ సరైన పాలిమార్ఫిక్ ఫంక్షన్: Pass by Reference
void inspectByReference(const Vehicle& v) {
    v.describe(); // అసలైన చైల్డ్ పాలిమార్ఫిక్ మెథడ్ రన్ అవుతుంది!
}

int main() {
    SuperCar ferrari;
    std::cout << "=== Pass by Value (స్లైసింగ్ వల్ల సూపర్ కార్ ఫీచర్లు కత్తిరించబడ్డాయి) ===\n";
    inspectByValue(ferrari);

    std::cout << "\n=== Pass by Reference (నిజమైన పాలిమార్ఫిజమ్ విజయవంతం!) ===\n";
    inspectByReference(ferrari);
    return 0;
}

#include <iostream>
#include <memory>

class PaymentGateway {
public:
    virtual void processPayment(double amount) {
        std::cout << "  💳 [బేస్ గేట్‌వే] సాధారణ చెల్లింపు ప్రాసెస్ అవుతోంది: ₹ " << amount << "\n";
    }

    virtual ~PaymentGateway() = default;
};

class UPIPayment : public PaymentGateway {
public:
    void processPayment(double amount) override {
        std::cout << "  📱 [UPI గేట్‌వే] NPCI సర్వర్ ద్వారా తక్షణ UPI చెల్లింపు: ₹ " << amount << "\n";
    }
};

class CreditCardPayment : public PaymentGateway {
public:
    void processPayment(double amount) override {
        std::cout << "  💳 [క్రెడిట్ కార్డ్] Visa/Mastercard 3D-Secure OTP ప్రాసెస్: ₹ " << amount << "\n";
    }
};

void executeTransaction(PaymentGateway* gateway, double amount) {
    gateway->processPayment(amount);
}

int main() {
    std::cout << "===== C++ Virtual Functions Polymorphism =====\n";
    UPIPayment upi;
    CreditCardPayment card;

    executeTransaction(&upi, 1500.0);  // UPI మెథడ్ కాల్ అవుతుంది
    executeTransaction(&card, 4500.0); // Credit Card మెథడ్ కాల్ అవుతుంది
    return 0;
}

#include <iostream>

class BaseLogger {
public:
    virtual void log(const std::string& msg) {
        std::cout << "[BaseLog]: " << msg << "\n";
    }
    virtual ~BaseLogger() = default;
};

class ConsoleLogger : public BaseLogger {
public:
    // override కీవర్డ్ కంపైలర్ చేత సిగ్నేచర్‌ను ఖచ్చితంగా వెరిఫై చేయిస్తుంది!
    void log(const std::string& msg) override {
        std::cout << "🖥️ [Console]: " << msg << "\n";
    }
};

// final క్లాస్: దీనిని ఇక ఎవరూ ఇన్హెరిట్ చేసుకోలేరు!
class SecureAuditor final : public BaseLogger {
public:
    // final మెథడ్: దీనిని చైల్డ్ క్లాసులు ఓవర్‌రైడ్ చేయలేవు
    void log(const std::string& msg) override final {
        std::cout << "🔒 [SHA-256 Secure Audit Log]: " << msg << "\n";
    }
};

int main() {
    ConsoleLogger cLog;
    SecureAuditor sLog;

    BaseLogger* p1 = &cLog;
    BaseLogger* p2 = &sLog;

    p1->log("User logged in");
    p2->log("Admin accessed ledger");
    return 0;
}

#include <iostream>
#include <vector>

// అబ్‌స్ట్రాక్ట్ ఇంటర్‌ఫేస్ (కాంట్రాక్ట్)
class AudioCodec {
public:
    virtual void decodePacket(const std::string& rawBytes) = 0; // Pure Virtual!
    virtual void encodePacket() = 0;                             // Pure Virtual!
    virtual ~AudioCodec() = default;
};

class MP3Codec : public AudioCodec {
public:
    void decodePacket(const std::string& rawBytes) override {
        std::cout << "  🎵 [MP3 డీకోడర్] MPEG-1 Layer III ఫ్రేమ్ ప్రాసెస్ అయ్యింది.\n";
    }
    void encodePacket() override {
        std::cout << "  🎵 [MP3 ఎన్‌కోడర్] 320 kbps ఆడియో కంప్రెషన్ పూర్తయింది.\n";
    }
};

class FLACCodec : public AudioCodec {
public:
    void decodePacket(const std::string& rawBytes) override {
        std::cout << "  🎧 [FLAC డీకోడర్] లాస్‌లెస్ 24-bit 192kHz హై-రెస్ ఆడియో ప్లేబ్యాక్.\n";
    }
    void encodePacket() override {
        std::cout << "  🎧 [FLAC ఎన్‌కోడర్] జీరో క్వాలిటీ లాస్ కంప్రెషన్.\n";
    }
};

int main() {
    // AudioCodec codec; // ❌ కంపైలర్ ఎర్రర్! అబ్‌స్ట్రాక్ట్ క్లాస్ కు ఆబ్జెక్ట్ సృష్టించలేము!
    MP3Codec mp3;
    FLACCodec flac;

    AudioCodec* player = &flac;
    player->decodePacket("0xFFE3_PCM_DATA");
    return 0;
}

#include <iostream>

class BaseResource {
public:
    BaseResource() { std::cout << "  [Base] రిసోర్స్ కేటాయించబడింది.\n"; }
    // 💡 వర్చువల్ డిస్ట్రక్టర్ లేకపోతే చైల్డ్ మెమరీ శాశ్వతంగా లీక్ అవుతుంది!
    virtual ~BaseResource() { std::cout << "  [Base] రిసోర్స్ సురక్షితంగా క్లీన్ అయింది.\n"; }
};

class HeavyDerived : public BaseResource {
private:
    int* heapBuffer;
public:
    HeavyDerived() : heapBuffer(new int[5000]) {
        std::cout << "  [Derived] 20,000 బైట్ల హీప్ మెమరీ కేటాయించబడింది.\n";
    }
    ~HeavyDerived() override {
        std::cout << "  [Derived] హీప్ బఫర్ లీక్ కాకుండా డిలీట్ చేయబడింది!\n";
        delete[] heapBuffer;
    }
};

int main() {
    std::cout << "===== వర్చువల్ డిస్ట్రక్టర్ లైఫ్‌సైకిల్ పరీక్ష =====\n";
    BaseResource* ptr = new HeavyDerived();

    // delete ptr పిలిచినప్పుడు:
    // 1. ముందుగా HeavyDerived డిస్ట్రక్టర్ కాల్ అవుతుంది
    // 2. తర్వాత BaseResource డిస్ట్రక్టర్ కాల్ అవుతుంది
    delete ptr;

    std::cout << "మెమరీ లీక్ లేకుండా క్లీనప్ విజయవంతమైంది!\n";
    return 0;
}

#include <iostream>

class Animal {
public:
    virtual void speak() const = 0;
    virtual ~Animal() = default;
};

class Dog : public Animal {
public:
    void speak() const override { std::cout << "  🐶 బౌ బౌ!\n"; }
    void fetchBall() const { std::cout << "  🎾 కుక్క బంతిని తెచ్చింది!\n"; }
};

class Cat : public Animal {
public:
    void speak() const override { std::cout << "  🐱 మియావ్!\n"; }
};

void identifyAndPlay(Animal* a) {
    a->speak(); // పాలిమార్ఫిక్ కాల్

    // సురక్షిత డౌన్‌కాస్టింగ్: ఇది కుక్క అయితేనే బంతిని ఆడుతుంది!
    Dog* dogPtr = dynamic_cast<Dog*>(a);
    if (dogPtr != nullptr) {
        dogPtr->fetchBall();
    } else {
        std::cout << "  ℹ️ ఇది కుక్క కాదు, బంతి తీసుకురాదు.\n";
    }
}

int main() {
    Dog myDog;
    Cat myCat;

    identifyAndPlay(&myDog);
    identifyAndPlay(&myCat);
    return 0;
}

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

// అబ్‌స్ట్రాక్ట్ బేస్ ఇంటర్‌ఫేస్ (Abstract Base Class)
class CloudProvider {
protected:
    std::string providerName;
    std::string region;

public:
    CloudProvider(std::string name, std::string reg) : providerName(name), region(reg) {}

    virtual ~CloudProvider() {
        std::cout << "  🗑️ [CloudProvider Destructor] " << providerName << " రిసోర్సులు క్లీన్ చేయబడ్డాయి.\n";
    }

    virtual void provisionComputeInstance(const std::string& instanceType, int count) = 0;
    virtual void deployKubernetesCluster(const std::string& clusterName, int nodes) = 0;
    virtual double calculateEstimatedHourlyCost() const = 0;

    std::string getProviderName() const { return providerName; }
};

class AWSProvider : public CloudProvider {
public:
    AWSProvider(std::string reg) : CloudProvider("Amazon Web Services (AWS)", reg) {}

    void provisionComputeInstance(const std::string& instanceType, int count) override {
        std::cout << "  ☁️ [AWS EC2] " << count << "x " << instanceType << " ఇన్స్టాన్స్‌లు " << region << " లో లాంచ్ అయ్యాయి!\n";
    }

    void deployKubernetesCluster(const std::string& clusterName, int nodes) override {
        std::cout << "  ☸️ [AWS EKS] అమెజాన్ ఎలాస్టిక్ కుబెర్‌నెటీస్ సర్వీస్: " << clusterName << " (" << nodes << " Worker Nodes)\n";
    }

    double calculateEstimatedHourlyCost() const override {
        return 12.50;
    }
};

class GCPProvider : public CloudProvider {
public:
    GCPProvider(std::string reg) : CloudProvider("Google Cloud Platform (GCP)", reg) {}

    void provisionComputeInstance(const std::string& instanceType, int count) override {
        std::cout << "  🌐 [GCP Compute Engine] " << count << "x " << instanceType << " VM లు " << region << " జోన్‌లో ప్రారంభమయ్యాయి!\n";
    }

    void deployKubernetesCluster(const std::string& clusterName, int nodes) override {
        std::cout << "  ☸️ [Google GKE] ఆటోపైలట్ కుబెర్‌నెటీస్ క్లస్టర్: " << clusterName << " (" << nodes << " Compute Nodes)\n";
    }

    double calculateEstimatedHourlyCost() const override {
        return 10.80;
    }
};

class AzureProvider : public CloudProvider {
public:
    AzureProvider(std::string reg) : CloudProvider("Microsoft Azure", reg) {}

    void provisionComputeInstance(const std::string& instanceType, int count) override {
        std::cout << "  🔷 [Azure Virtual Machines] " << count << "x " << instanceType << " VM లు " << region << " లో సిద్ధమయ్యాయి!\n";
    }

    void deployKubernetesCluster(const std::string& clusterName, int nodes) override {
        std::cout << "  ☸️ [Azure AKS] అజూర్ కుబెర్‌నెటీస్ సర్వీస్ క్లస్టర్: " << clusterName << " (" << nodes << " Nodes)\n";
    }

    double calculateEstimatedHourlyCost() const override {
        return 11.75;
    }
};

int main() {
    std::cout << "=======================================================================\n";
    std::cout << "🚀 [ENTERPRISE MULTI-CLOUD ORCHESTRATION & DEPLOYMENT ENGINE]\n";
    std::cout << "=======================================================================\n";

    std::vector<std::unique_ptr<CloudProvider>> cloudFleet;

    cloudFleet.push_back(std::make_unique<AWSProvider>("ap-south-1 (Mumbai)"));
    cloudFleet.push_back(std::make_unique<GCPProvider>("asia-south1 (Delhi)"));
    cloudFleet.push_back(std::make_unique<AzureProvider>("central-india (Pune)"));

    double totalFleetHourlyCost = 0.0;

    std::cout << "\n[మల్టీ-క్లౌడ్ డిప్లాయ్‌మెంట్ ఆటోమేషన్ రన్ అవుతోంది]:\n\n";
    for (const auto& provider : cloudFleet) {
        std::cout << ">>> ఆర్కెస్ట్రేషన్ ప్రొవైడర్: " << provider->getProviderName() << "\n";
        provider->provisionComputeInstance("m5.2xlarge", 4);
        provider->deployKubernetesCluster("prod-banking-mesh", 8);

        double cost = provider->calculateEstimatedHourlyCost();
        totalFleetHourlyCost += cost;
        std::cout << "    అంచనా గంట ఖర్చు: $ " << std::fixed << std::setprecision(2) << cost << "\n\n";
    }

    std::cout << "=======================================================================\n";
    std::cout << "💰 మొత్తం మల్టీ-క్లౌడ్ నెట్‌వర్క్ గంట ఖర్చు: $ " << totalFleetHourlyCost << " / Hour\n";
    std::cout << "=======================================================================\n";
    std::cout << "ప్రోగ్రామ్ ముగింపు: వర్చువల్ డిస్ట్రక్టర్లు అన్ని క్లౌడ్ రిసోర్సులను సురక్షితంగా క్లీన్ చేస్తాయి!\n";
    return 0;
}