ఇన్హెరిటెన్స్ (Inheritance)

#include <iostream>
#include <string>

// లెవల్ 1: Base Class
class Device {
public:
    void powerOn() {
        std::cout << "  [Device] విద్యుత్ సరఫరా ఆన్ చేయబడింది.\n";
    }
};

// లెవల్ 2: Derived from Device
class Computer : public Device {
public:
    void bootOS() {
        std::cout << "  [Computer] ఆపరేటింగ్ సిస్టమ్ బూట్ అవుతోంది...\n";
    }
};

// లెవల్ 3: Derived from Computer (Multilevel)
class Laptop : public Computer {
public:
    void checkBattery() {
        std::cout << "  [Laptop] బ్యాటరీ నిల్వ: 92%\n";
    }
};

int main() {
    Laptop myLaptop;
    std::cout << "===== మల్టీలెవల్ ఇన్హెరిటెన్స్ ఫ్లో =====\n";
    myLaptop.powerOn();     // లెవల్ 1 ఫంక్షన్
    myLaptop.bootOS();      // లెవల్ 2 ఫంక్షన్
    myLaptop.checkBattery(); // లెవల్ 3 ఫంక్షన్
    return 0;
}

#include <iostream>

class CameraModule {
public:
    void capturePhoto() {
        std::cout << "  📸 48MP హై-రిజల్యూషన్ ఫోటో తీయబడింది!\n";
    }
};

class CellularModem {
public:
    void makeCall(const std::string& number) {
        std::cout << "  📞 5G నెట్‌వర్క్ ద్వారా " << number << " కి కాల్ కనెక్ట్ అవుతోంది...\n";
    }
};

// రెండు స్వతంత్ర క్లాసుల నుండి మల్టిపుల్ ఇన్హెరిటెన్స్
class ModernSmartphone : public CameraModule, public CellularModem {
public:
    void browseWeb() {
        std::cout << "  🌐 బ్రౌజర్‌లో ఇంటర్నెట్ లోడ్ అవుతోంది...\n";
    }
};

int main() {
    ModernSmartphone phone;
    std::cout << "===== C++ మల్టిపుల్ ఇన్హెరిటెన్స్ డెమో =====\n";
    phone.capturePhoto();
    phone.makeCall("+91-9876543210");
    phone.browseWeb();
    return 0;
}

#include <iostream>

class PoweredDevice {
public:
    int voltage;
    PoweredDevice(int v) : voltage(v) {
        std::cout << "  ⚡ [PoweredDevice] వోల్టేజ్ ఇనిషియలైజ్ చేయబడింది: " << voltage << "V\n";
    }
};

// 💡 వర్చువల్ ఇన్హెరిటెన్స్ ద్వారా డైమండ్ ప్రాబ్లమ్ పరిష్కారం!
class Scanner : virtual public PoweredDevice {
public:
    Scanner(int v) : PoweredDevice(v) {
        std::cout << "  📠 Scanner మాడ్యూల్ రెడీ.\n";
    }
};

class Printer : virtual public PoweredDevice {
public:
    Printer(int v) : PoweredDevice(v) {
        std::cout << "  🖨️ Printer మాడ్యూల్ రెడీ.\n";
    }
};

class CopierMachine : public Scanner, public Printer {
public:
    // వర్చువల్ బేస్ క్లాస్ ఉన్నప్పుడు, మోస్ట్ డిరైవ్డ్ క్లాస్ నేరుగా అపెక్స్ బేస్‌ను పిలవాలి!
    CopierMachine(int v) : PoweredDevice(v), Scanner(v), Printer(v) {
        std::cout << "  🏢 CopierMachine పూర్తిగా ఆపరేషనల్!\n";
    }
};

int main() {
    std::cout << "===== Virtual Base Class డైమండ్ పరిష్కార పరీక్ష =====\n";
    CopierMachine copier(240);

    // అంబిగ్యుటీ లేకుండా నేరుగా voltage ను యాక్సెస్ చేయవచ్చు!
    std::cout << "\nకాపియర్ వోల్టేజ్: " << copier.voltage << "V (ఏకైక షేర్డ్ ఇన్స్టాన్స్!)\n";
    return 0;
}

#include <iostream>

class Parent {
public:
    Parent() { std::cout << "  1. [Parent Constructor] పునాది వేయబడింది.\n"; }
    ~Parent() { std::cout << "  4. [Parent Destructor] పునాది తొలగించబడింది.\n"; }
};

class Child : public Parent {
public:
    Child() { std::cout << "  2. [Child Constructor] భవనం నిర్మించబడింది.\n"; }
    ~Child() { std::cout << "  3. [Child Destructor] భవనం కూల్చబడింది.\n"; }
};

int main() {
    std::cout << "స్కోప్ ప్రారంభం...\n";
    {
        Child c;
    } // ఇక్కడ స్కోప్ ముగిసింది
    std::cout << "స్కోప్ ముగిసింది.\n";
    return 0;
}

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

// అపెక్స్ బేస్ క్లాస్: ఏవియోనిక్స్ పవర్ & టెలిమెట్రీ
class AvionicsCore {
protected:
    std::string droneSerial;
    double currentBatteryKWh;
    double altitudeMeters;

public:
    AvionicsCore(std::string serial, double battery)
        : droneSerial(serial), currentBatteryKWh(battery), altitudeMeters(0.0) {
        std::cout << "  🚁 [AvionicsCore Base] పవర్ బస్ ఆన్ చేయబడింది: " << droneSerial 
                  << " (బ్యాటరీ: " << currentBatteryKWh << " kWh)\n";
    }

    virtual ~AvionicsCore() {
        std::cout << "  🛑 [AvionicsCore Base] ఏవియోనిక్స్ పవర్ సురక్షితంగా షట్‌డౌన్ చేయబడింది.\n";
    }

    void climb(double meters) {
        altitudeMeters += meters;
        currentBatteryKWh -= (meters * 0.001);
        std::cout << "  ✈️ [ఎత్తు పెంపు] ఎత్తు: " << altitudeMeters << " మీటర్లు | మిగిలిన పవర్: " << currentBatteryKWh << " kWh\n";
    }
};

// బ్రాంచ్ 1: వర్చువల్ బేస్ ఇన్హెరిటెన్స్ (డైమండ్ నివారణ)
class SurveillanceRadar : virtual public AvionicsCore {
protected:
    double radarScanRangeKm;

public:
    SurveillanceRadar(std::string serial, double battery, double scanRange)
        : AvionicsCore(serial, battery), radarScanRangeKm(scanRange) {
        std::cout << "  📡 [SurveillanceRadar] AESA రాడార్ యాక్టివేట్ చేయబడింది (పరిధి: " << radarScanRangeKm << " KM)\n";
    }

    void scanForHostiles() {
        std::cout << "  🔍 [రాడార్ స్కానింగ్] " << radarScanRangeKm << " KM పరిధిలో గగనతల శత్రు లక్ష్యాల అన్వేషణ జరుగుతోంది...\n";
    }
};

// బ్రాంచ్ 2: వర్చువల్ బేస్ ఇన్హెరిటెన్స్ (డైమండ్ నివారణ)
class PrecisionWeaponBay : virtual public AvionicsCore {
protected:
    int payloadMissiles;

public:
    PrecisionWeaponBay(std::string serial, double battery, int missiles)
        : AvionicsCore(serial, battery), payloadMissiles(missiles) {
        std::cout << "  🎯 [PrecisionWeaponBay] గైడెడ్ క్షిపణి లాంచర్ లోడ్ చేయబడింది (మిస్సైల్స్: " << payloadMissiles << ")\n";
    }

    void fireMissile(const std::string& targetCoordinates) {
        if (payloadMissiles > 0) {
            payloadMissiles--;
            std::cout << "  🚀 [మిస్సైల్ ప్రయోగం!] టార్గెట్ కోఆర్డినేట్స్: " << targetCoordinates 
                      << " పైకి క్షిపణి దూసుకెళ్లింది! (మిగిలినవి: " << payloadMissiles << ")\n";
        } else {
            std::cout << "  ⚠️ హెచ్చరిక: క్షిపణులు అయిపోయాయి! వెంటనే బేస్ కు తిరిగి రండి.\n";
        }
    }
};

// డైమండ్ చైల్డ్: మల్టిపుల్ ఇన్హెరిటెన్స్ ఫ్రమ్ SurveillanceRadar & PrecisionWeaponBay
class CombatStealthUAV : public SurveillanceRadar, public PrecisionWeaponBay {
private:
    std::string callSign;

public:
    // మోస్ట్ డిరైవ్డ్ క్లాస్ నేరుగా వర్చువల్ అపెక్స్ బేస్ (AvionicsCore) ను ఇనిషియలైజ్ చేయాలి!
    CombatStealthUAV(std::string serial, std::string callName, double battery, double scanRange, int missiles)
        : AvionicsCore(serial, battery),
          SurveillanceRadar(serial, battery, scanRange),
          PrecisionWeaponBay(serial, battery, missiles),
          callSign(callName) {
        std::cout << "\n  ⚡ [COMBAT STEALTH UAV READY] కాల్‌సైన్: " << callSign << " పోరాటానికి సిద్ధం!\n";
    }

    void executeCombatMission(const std::string& targetGrid) {
        std::cout << "\n==============================================================\n";
        std::cout << "⚔️ [మిషన్ ఎగ్జిక్యూషన్ - " << callSign << " / " << droneSerial << "]\n";
        std::cout << "==============================================================\n";
        climb(12000.0); // 12 కిమీ ఎత్తుకు ఎగరడం
        scanForHostiles();
        fireMissile(targetGrid);
        std::cout << "లక్ష్యం ధ్వంసమైంది! బేస్ కు తిరుగు ప్రయాణం ప్రారంభం...\n";
        std::cout << "==============================================================\n";
    }
};

int main() {
    std::cout << "==============================================================\n";
    std::cout << "🛡️ [DEFENSE AEROSPACE COMBAT DRONE SIMULATION RUNNING]\n";
    std::cout << "==============================================================\n";

    {
        // డ్రోన్ సృష్టి (సింగిల్ షేర్డ్ ఏవియోనిక్స్ పవర్ కోర్ తో!)
        CombatStealthUAV droneX("DRONE_IAF_GHAATAK_01", "GARUDA_STRIKE", 250.0, 150.0, 4);

        // మిషన్ అమలు
        droneX.executeCombatMission("SECTOR_4_ENEMY_RADAR_BUNKER_34.5N_72.8E");
    } // స్కోప్ ముగియగానే రివర్స్ ఆర్డర్‌లో అన్నీ లీక్-ఫ్రీగా క్లీన్ అవుతాయి!

    std::cout << "\nమిషన్ ముగింపు. వర్చువల్ ఇన్హెరిటెన్స్ ఆర్కిటెక్చర్ విజయవంతమైంది!\n";
    return 0;
}