డైనమిక్ మెమరీ & Smart Pointers

#include <iostream>

int main() {
    // 1. హీప్‌పై ఒక సింగిల్ ఇంటిజర్‌ను అలొకేట్ చేయడం
    int* ptr = new int(100); // హీప్‌పై 4 బైట్లు కేటాయించి 100 స్టోర్ చేస్తుంది
    std::cout << "హీప్ అడ్రస్: " << ptr << " | విలువ: " << *ptr << "\n";

    // ఉపయోగించిన తర్వాత తప్పనిసరిగా డిలీట్ చేయాలి!
    delete ptr;
    ptr = nullptr; // డాంగ్లింగ్ కాకుండా సేఫ్‌గా నల్ చేయడం

    // 2. హీప్‌పై డైనమిక్ అర్రే అలొకేషన్
    int size = 5;
    int* dynamicArr = new int[size]; // 5 పూర్ణాంకాల మెమరీ కేటాయింపు

    for (int i = 0; i < size; ++i) {
        dynamicArr[i] = (i + 1) * 10;
    }

    std::cout << "డైనమిక్ అర్రే మూడవ ఎలిమెంట్: " << dynamicArr[2] << "\n";

    // ⚠️ అత్యంత ముఖ్యం: అర్రేలను delete[] తో మాత్రమే డిలీట్ చేయాలి!
    delete[] dynamicArr;
    dynamicArr = nullptr;

    return 0;
}

#include <iostream>

void processUserData() {
    int* buffer = new int[1000]; // 4000 బైట్లు కేటాయించాం

    bool errorOccurred = true;
    if (errorOccurred) {
        // పొరపాటు: ఎర్రర్ రాగానే ఫంక్షన్ నుండి బయటకు వెళ్లిపోయాం!
        // delete[] buffer చేయలేదు!
        std::cout << "❌ లోపం సంభవించింది! మెమరీ లీక్ అయ్యింది (4000 Bytes కోల్పోయాం).\n";
        return; 
    }

    delete[] buffer;
}

int main() {
    for (int i = 0; i < 3; ++i) {
        processUserData();
    }
    return 0;
}

#include <iostream>

// RAII Wrapper క్లాస్
class SafeIntBuffer {
private:
    int* data;
public:
    SafeIntBuffer(int val) {
        data = new int(val);
        std::cout << "  [RAII కన్‌స్ట్రక్టర్] హీప్ మెమరీ కేటాయించబడింది: " << *data << "\n";
    }

    ~SafeIntBuffer() {
        std::cout << "  [RAII డిస్ట్రక్టర్] ఆటోమేటిక్‌గా మెమరీ విడుదల చేయబడింది: " << *data << "\n";
        delete data;
    }

    int getValue() const { return *data; }
};

int main() {
    std::cout << "స్కోప్ ప్రారంభం...\n";
    {
        SafeIntBuffer buffer(777); // స్టాక్ ఆబ్జెక్ట్ సృష్టించబడింది
        std::cout << "బఫర్ విలువ: " << buffer.getValue() << "\n";
    } // <-- ఇక్కడ స్కోప్ ముగిసింది! డిస్ట్రక్టర్ స్వయంచాలకంగా పిలువబడుతుంది!
    std::cout << "స్కోప్ ముగిసింది! మెమరీ లీక్ సున్నా!\n";
    return 0;
}

#include <iostream>
#include <memory>
#include <string>

class DeviceNode {
public:
    std::string name;
    DeviceNode(std::string n) : name(n) {
        std::cout << "  🔌 పరికరం ఆన్‌లైన్ అయ్యింది: " << name << "\n";
    }
    ~DeviceNode() {
        std::cout << "  🛑 పరికరం సురక్షితంగా షట్‌డౌన్ అయ్యింది: " << name << "\n";
    }
    void ping() const {
        std::cout << "  📡 Ping విజయవంతమైంది: " << name << "\n";
    }
};

int main() {
    std::cout << "===== std::unique_ptr డెమో =====\n";

    // C++14 make_unique ఉపయోగించి సురక్షిత సృష్టి
    std::unique_ptr<DeviceNode> dev1 = std::make_unique<DeviceNode>("Router_A1");
    dev1->ping();

    // std::unique_ptr<DeviceNode> dev2 = dev1; // ❌ కంపైలర్ ఎర్రర్! కాపీ చేయడం నిషిద్ధం!

    std::cout << "\nఓనర్‌షిప్‌ను dev2 కు బదిలీ (std::move) చేస్తున్నాం...\n";
    std::unique_ptr<DeviceNode> dev2 = std::move(dev1);

    if (dev1 == nullptr) {
        std::cout << "dev1 ఇప్పుడు సురక్షితంగా nullptr (ఖాళీ) అయ్యింది.\n";
    }
    dev2->ping();

    std::cout << "\nమెయిన్ ఫంక్షన్ ముగింపు...\n";
    return 0; // dev2 స్కోప్ ముగియగానే DeviceNode ఆటోమేటిక్‌గా డిస్ట్రక్ట్ అవుతుంది!
}

#include <iostream>
#include <memory>

class DatabaseConnection {
public:
    DatabaseConnection() { std::cout << "  🗄️ డేటాబేస్ కనెక్షన్ ఓపెన్ అయ్యింది!\n"; }
    ~DatabaseConnection() { std::cout << "  🔒 డేటాబేస్ కనెక్షన్ పూర్తిగా క్లోజ్ చేయబడింది!\n"; }
    void query() { std::cout << "  ⚡ SQL Query అమలు చేయబడుతోంది...\n"; }
};

int main() {
    std::cout << "===== std::shared_ptr రిఫరెన్స్ కౌంటింగ్ డెమో =====\n";

    // make_shared ద్వారా సింగిల్ మెమరీ అలొకేషన్
    std::shared_ptr<DatabaseConnection> conn1 = std::make_shared<DatabaseConnection>();
    std::cout << "conn1 ప్రారంభం | రిఫరెన్స్ కౌంట్: " << conn1.use_count() << "\n";

    {
        std::shared_ptr<DatabaseConnection> conn2 = conn1; // కాపీ సవ్యమైనది!
        std::cout << "conn2 చేరింది    | రిఫరెన్స్ కౌంట్: " << conn1.use_count() << "\n";

        {
            std::shared_ptr<DatabaseConnection> conn3 = conn2;
            std::cout << "conn3 చేరింది    | రిఫరెన్స్ కౌంట్: " << conn1.use_count() << "\n";
            conn3->query();
        } // conn3 నశించింది

        std::cout << "conn3 వెళ్ళిపోయింది | రిఫరెన్స్ కౌంట్: " << conn1.use_count() << "\n";
    } // conn2 నశించింది

    std::cout << "conn2 వెళ్ళిపోయింది | రిఫరెన్స్ కౌంట్: " << conn1.use_count() << "\n";
    std::cout << "మెయిన్ ఫంక్షన్ ముగింపు...\n";
    return 0; // conn1 నశించగానే కౌంట్ 0 అయ్యి డేటాబేస్ కనెక్షన్ క్లోజ్ అవుతుంది!
}

#include <iostream>
#include <memory>

struct NodeB; // ఫార్వర్డ్ డిక్లరేషన్

struct NodeA {
    std::shared_ptr<NodeB> ptrB;
    ~NodeA() { std::cout << "  NodeA డిస్ట్రక్ట్ అయ్యింది!\n"; }
};

struct NodeB {
    // 💡 సర్కిల్‌ను విచ్ఛిన్నం చేయడానికి weak_ptr వాడాం!
    std::weak_ptr<NodeA> ptrA; 
    ~NodeB() { std::cout << "  NodeB డిస్ట్రక్ట్ అయ్యింది!\n"; }
};

int main() {
    std::cout << "===== std::weak_ptr సైకిల్ నివారణ డెమో =====\n";
    {
        auto a = std::make_shared<NodeA>();
        auto b = std::make_shared<NodeB>();

        a->ptrB = b;
        b->ptrA = a; // weak_ptr అసైన్‌మెంట్ (use_count పెరగదు!)

        std::cout << "NodeA use_count: " << a.use_count() << "\n";
        std::cout << "NodeB use_count: " << b.use_count() << "\n";

        // weak_ptr నుండి డేటాను యాక్సెస్ చేసే విధానం:
        if (auto lockedA = b->ptrA.lock()) {
            std::cout << "weak_ptr సురక్షితంగా లాక్ చేయబడింది! ఆబ్జెక్ట్ సజీవంగా ఉంది.\n";
        }
    } // స్కోప్ ముగియగానే NodeA మరియు NodeB రెండూ సవ్యంగా డిస్ట్రక్ట్ అవుతాయి!

    std::cout << "స్కోప్ ముగిసింది. మెమరీ లీక్ విజయవంతంగా నివారించబడింది!\n";
    return 0;
}

#include <iostream>
#include <memory>
#include <cstdio>

// C-File హ్యాండిల్ కోసం కస్టమ్ డెలీటర్ లాంబ్డా
int main() {
    auto fileCloser = [](FILE* fp) {
        if (fp) {
            std::cout << "  📄 కస్టమ్ డెలీటర్: fclose() ద్వారా ఫైల్ ఆటోమేటిక్‌గా క్లోజ్ చేయబడింది!\n";
            std::fclose(fp);
        }
    };

    {
        // unique_ptr తో ఫైల్ హ్యాండిల్ నిర్వహణ
        std::unique_ptr<FILE, decltype(fileCloser)> myFile(std::fopen("test_log.txt", "w"), fileCloser);

        if (myFile) {
            std::fputs("Our Compiler Modern C++ RAII Log", myFile.get());
            std::cout << "ఫైల్‌లోకి లాగ్ డేటా వ్రాయబడింది.\n";
        }
    } // <-- ఇక్కడ స్కోప్ ముగియగానే ఫైల్ ఆటోమేటిక్‌గా క్లోజ్ అవుతుంది! fclose() పిలవాల్సిన పని లేదు!

    return 0;
}

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

// టెనెంట్ కాన్ఫిగరేషన్ (Exclusive Ownership: unique_ptr)
class TenantConfig {
public:
    std::string tenantId;
    int maxConnections;
    TenantConfig(std::string id, int maxConn) : tenantId(id), maxConnections(maxConn) {
        std::cout << "  🏢 [కన్ఫిగరేషన్ లోడ్ అయింది] టెనెంట్ ID: " << tenantId << "\n";
    }
    ~TenantConfig() {
        std::cout << "  🗑️ [కన్ఫిగరేషన్ డిస్ట్రాయ్ అయింది] టెనెంట్ ID: " << tenantId << "\n";
    }
};

// యూజర్ సెషన్ డేటా (Shared Ownership: shared_ptr)
class UserSession {
public:
    std::string sessionId;
    std::string username;
    UserSession(std::string sId, std::string user) : sessionId(sId), username(user) {
        std::cout << "  👤 [లాగిన్] సెషన్ ప్రారంభమైంది: " << username << " (ID: " << sessionId << ")\n";
    }
    ~UserSession() {
        std::cout << "  🚪 [లాగౌట్] సెషన్ మెమరీ ఆటోమేటిక్‌గా విడుదల చేయబడింది: " << username << "\n";
    }
    void executeAction(const std::string& action) {
        std::cout << "  ⚡ యాక్షన్ అమలు: " << username << " -> " << action << "\n";
    }
};

// క్లౌడ్ సెషన్ మేనేజర్ ఇంజిన్
class CloudSessionManager {
private:
    std::unordered_map<std::string, std::shared_ptr<UserSession>> activeSessions;
    std::vector<std::weak_ptr<UserSession>> sessionAuditLog; // Non-owning weak observer

public:
    void registerSession(std::shared_ptr<UserSession> session) {
        activeSessions[session->sessionId] = session;
        sessionAuditLog.push_back(session); // weak_ptr రూపంలో స్టోర్ అవుతుంది
        std::cout << "  [మేనేజర్] సెషన్ నమోదు చేయబడింది. ప్రస్తుత యాక్టివ్ సెషన్లు: " << activeSessions.size() << "\n";
    }

    void terminateSession(const std::string& sessionId) {
        std::cout << "\n[మేనేజర్] సెషన్ ముగింపు ఆదేశం: " << sessionId << "\n";
        activeSessions.erase(sessionId); // మ్యాప్ నుండి తొలగించగానే use_count తగ్గుతుంది
    }

    void runAuditInspection() {
        std::cout << "\n--- [సెక్యూరిటీ ఆడిట్ ఇన్‌స్పెక్షన్ (weak_ptr ద్వారా)] ---\n";
        for (size_t i = 0; i < sessionAuditLog.size(); ++i) {
            if (auto liveSession = sessionAuditLog[i].lock()) {
                std::cout << "  ✅ ఆడిట్ #" << (i + 1) << ": సెషన్ సజీవంగా ఉంది -> " << liveSession->username << "\n";
            } else {
                std::cout << "  ⚠️ ఆడిట్ #" << (i + 1) << ": సెషన్ ఇప్పటికే సురక్షితంగా క్లోజ్ చేయబడింది (Expired!)\n";
            }
        }
    }
};

int main() {
    std::cout << "=======================================================================\n";
    std::cout << "☁️ [ENTERPRISE CLOUD MULTI-TENANT SESSION & RESOURCE ENGINE]\n";
    std::cout << "=======================================================================\n";

    // 1. unique_ptr తో టెనెంట్ కాన్ఫిగరేషన్ (Zero-overhead exclusive ownership)
    std::unique_ptr<TenantConfig> tenant = std::make_unique<TenantConfig>("HDFC_BANK_PROD", 5000);

    CloudSessionManager manager;

    // 2. shared_ptr తో సెషన్ల నిర్వహణ
    auto user1 = std::make_shared<UserSession>("SESS_001", "Ravi_Kumar");
    auto user2 = std::make_shared<UserSession>("SESS_002", "Priya_Sharma");

    manager.registerSession(user1);
    manager.registerSession(user2);

    user1->executeAction("₹ 25,000 NEFT Transfer");
    user2->executeAction("Download Account Statement");

    manager.runAuditInspection();

    // Ravi Kumar లాగౌట్ అయ్యాడు
    manager.terminateSession("SESS_001");
    user1.reset(); // లోకల్ పాయింటర్ కూడా క్లియర్ చేశాం (use_count = 0)

    manager.runAuditInspection();

    std::cout << "\n=======================================================================\n";
    std::cout << "ప్రోగ్రామ్ ముగింపు: మిగిలిన అన్ని సెషన్లు మరియు కాన్ఫిగరేషన్లు RAII ద్వారా ఆటోమేటిక్‌గా క్లీన్ అవుతాయి!\n";
    std::cout << "=======================================================================\n";
    return 0;
}