Constructors, Destructors & RAII

#include <iostream>
#include <string>

class ServerNode {
public:
    std::string ipAddress;
    int port;

    // Modern C++11 Explicit Default Constructor
    ServerNode() = default;

    // Parameterized Constructor
    ServerNode(std::string ip, int p) : ipAddress(ip), port(p) {
        std::cout << "  [పారామీటరైజ్డ్ కన్‌స్ట్రక్టర్] నోడ్ ప్రారంభమైంది: " << ipAddress << ":" << port << "\n";
    }
};

int main() {
    ServerNode n1; // = default వల్ల సవ్యంగా పనిచేస్తుంది!
    n1.ipAddress = "127.0.0.1";
    n1.port = 8080;

    ServerNode n2("192.168.1.100", 443);
    return 0;
}

#include <iostream>

class Rectangle {
private:
    double width;
    double height;

public:
    // 1. చతురస్రం కొరకు సింగిల్ పారామీటర్ కన్‌స్ట్రక్టర్
    Rectangle(double side) : width(side), height(side) {
        std::cout << "చతురస్రం సృష్టించబడింది (Side: " << side << ")\n";
    }

    // 2. దీర్ఘచతురస్రం కొరకు డబుల్ పారామీటర్ కన్‌స్ట్రక్టర్
    Rectangle(double w, double h) : width(w), height(h) {
        std::cout << "దీర్ఘచతురస్రం సృష్టించబడింది (" << w << " x " << h << ")\n";
    }

    double getArea() const { return width * height; }
};

int main() {
    Rectangle square(10.0);
    Rectangle rect(20.0, 5.0);

    std::cout << "చతురస్ర వైశాల్యం: " << square.getArea() << "\n";
    std::cout << "దీర్ఘచతురస్ర వైశాల్యం: " << rect.getArea() << "\n";
    return 0;
}

#include <iostream>
#include <string>

class HardwarePort {
private:
    const int portNumber; // const మెంబర్ - బాడీలో అసైన్ చేయలేం!
    std::string& logTarget; // reference మెంబర్ - తప్పనిసరిగా లిస్ట్‌లోనే బైండ్ చేయాలి!
    std::string protocol;

public:
    // మెంబర్ ఇనిషియలైజర్ లిస్ట్ సింటాక్స్:
    HardwarePort(int port, std::string& log, std::string proto)
        : portNumber(port), logTarget(log), protocol(proto) {
        // ఇక్కడ బాడీలో ఏమీ చేయాల్సిన పనిలేదు!
        logTarget += "[Port Initialized: " + std::to_string(portNumber) + "] ";
    }

    void status() const {
        std::cout << "పోర్ట్: " << portNumber << " | ప్రోటోకాల్: " << protocol << "\n";
    }
};

int main() {
    std::string systemLog = "LOG_START -> ";
    HardwarePort p1(8080, systemLog, "HTTPS");
    p1.status();

    std::cout << "సిస్టమ్ లాగ్: " << systemLog << "\n";
    return 0;
}

#include <iostream>
#include <string>

class CloudInstance {
public:
    std::string instanceType;
    int cpuCores;
    int ramGB;

    // ప్రధాన టార్గెట్ కన్‌స్ట్రక్టర్
    CloudInstance(std::string type, int cores, int ram)
        : instanceType(type), cpuCores(cores), ramGB(ram) {
        std::cout << "  [CloudInstance Target] " << instanceType 
                  << " (" << cpuCores << " Cores, " << ramGB << " GB RAM)\n";
    }

    // డెలిగేటింగ్ కన్‌స్ట్రక్టర్ 1 (కేవలం టైప్ ఇస్తే చాలు)
    CloudInstance(std::string type) : CloudInstance(type, 2, 4) {}

    // డెలిగేటింగ్ కన్‌స్ట్రక్టర్ 2 (డిఫాల్ట్ మైక్రో ఇన్స్టాన్స్)
    CloudInstance() : CloudInstance("t3.micro", 1, 1) {}
};

int main() {
    CloudInstance c1;                   // డెలిగేట్ చేస్తుంది -> t3.micro
    CloudInstance c2("c5.xlarge");       // డెలిగేట్ చేస్తుంది -> c5.xlarge, 2, 4
    CloudInstance c3("m5.2xlarge", 8, 32); // టార్గెట్ డైరెక్ట్ కాల్
    return 0;
}

#include <iostream>

class DynamicArray {
private:
    int* buffer;
    size_t size;

public:
    DynamicArray(size_t s) : size(s), buffer(new int[s]) {
        std::cout << "  [కన్‌స్ట్రక్టర్] హీప్ మెమరీ కేటాయించబడింది (" << size << " అంశాలు) అడ్రస్: " << buffer << "\n";
    }

    // కస్టమ్ డీప్ కాపీ కన్‌స్ట్రక్టర్ (Deep Copy Constructor)
    DynamicArray(const DynamicArray& other) : size(other.size), buffer(new int[other.size]) {
        for (size_t i = 0; i < size; ++i) {
            buffer[i] = other.buffer[i];
        }
        std::cout << "  [డీప్ కాపీ కన్‌స్ట్రక్టర్] స్వతంత్ర కొత్త మెమరీ కేటాయించబడింది: " << buffer << "\n";
    }

    ~DynamicArray() {
        std::cout << "  [డిస్ట్రక్టర్] మెమరీ విడుదల చేయబడింది: " << buffer << "\n";
        delete[] buffer;
    }

    void set(size_t idx, int val) { buffer[idx] = val; }
    int get(size_t idx) const { return buffer[idx]; }
};

int main() {
    {
        DynamicArray a1(5);
        a1.set(0, 999);

        // a1 ఆధారంగా a2 సృష్టి (డీప్ కాపీ రన్ అవుతుంది!)
        DynamicArray a2 = a1;
        std::cout << "a2[0] విలువ: " << a2.get(0) << "\n";
    } // రెండు ఆబ్జెక్టులూ తమ స్వంత మెమరీని సురక్షితంగా విడుదల చేసుకుంటాయి! డబుల్ ఫ్రీ క్రాష్ లేదు!
    return 0;
}

#include <iostream>
#include <utility> // std::move కొరకు

class HeavyBuffer {
public:
    int* data;
    size_t size;

    HeavyBuffer(size_t s) : size(s), data(new int[s]) {
        std::cout << "  [అలొకేషన్] " << size << " పూర్ణాంకాల మెమరీ కేటాయించబడింది.\n";
    }

    // మూవ్ కన్‌స్ట్రక్టర్ (Move Constructor - Zero Memory Copy!)
    HeavyBuffer(HeavyBuffer&& other) noexcept : data(other.data), size(other.size) {
        other.data = nullptr; // పాత ఆబ్జెక్ట్ నుండి ఓనర్‌షిప్ లాగేసుకున్నాం!
        other.size = 0;
        std::cout << "  ⚡ [MOVE కన్‌స్ట్రక్టర్] పాయింటర్ బదిలీ చేయబడింది! సున్నా ఓవర్‌హెడ్!\n";
    }

    ~HeavyBuffer() {
        if (data != nullptr) {
            std::cout << "  [డిస్ట్రక్టర్] మెమరీ క్లీన్ చేయబడింది.\n";
            delete[] data;
        } else {
            std::cout << "  [డిస్ట్రక్టర్] ఖాళీ మూవ్డ్ ఆబ్జెక్ట్ - ఏమీ చేయలేదు.\n";
        }
    }
};

int main() {
    HeavyBuffer buf1(100000);

    // std::move ద్వారా buf1 ని Rvalue గా మార్చి మూవ్ కన్‌స్ట్రక్టర్‌ను పిలుస్తున్నాం
    HeavyBuffer buf2 = std::move(buf1);

    std::cout << "buf1.data ఇప్పుడు nullptr? " << (buf1.data == nullptr ? "అవును" : "కాదు") << "\n";
    return 0;
}

#include <iostream>
#include <string>

class Tracer {
private:
    std::string name;
public:
    Tracer(std::string n) : name(n) {
        std::cout << "  🌱 సృష్టించబడింది: " << name << "\n";
    }
    ~Tracer() {
        std::cout << "  🍂 నాశనమైంది (Destructor): " << name << "\n";
    }
};

int main() {
    std::cout << "మెయిన్ ఫంక్షన్ ప్రారంభం...\n";
    Tracer t1("మొదటిది (First)");
    Tracer t2("రెండవది (Second)");
    Tracer t3("మూడవది (Third)");

    std::cout << "స్కోప్ ముగుస్తోంది... LIFO రివర్స్ ఆర్డర్ గమనించండి!\n";
    return 0;
}

#include <iostream>
#include <utility>
#include <algorithm>

class MatrixEngine {
private:
    size_t rows;
    size_t cols;
    double** data;

    void allocateMemory() {
        data = new double*[rows];
        for (size_t i = 0; i < rows; ++i) {
            data[i] = new double[cols]();
        }
    }

    void releaseMemory() {
        if (data != nullptr) {
            for (size_t i = 0; i < rows; ++i) {
                delete[] data[i];
            }
            delete[] data;
            data = nullptr;
        }
    }

public:
    // 1. Parameterized Constructor
    MatrixEngine(size_t r, size_t c) : rows(r), cols(c), data(nullptr) {
        allocateMemory();
        std::cout << "  🏗️ [కన్‌స్ట్రక్టర్] " << rows << "x" << cols << " మ్యాట్రిక్స్ కేటాయించబడింది.\n";
    }

    // 2. Destructor
    ~MatrixEngine() {
        if (data != nullptr) {
            std::cout << "  🗑️ [డిస్ట్రక్టర్] " << rows << "x" << cols << " మ్యాట్రిక్స్ మెమరీ విడుదల చేయబడింది.\n";
            releaseMemory();
        } else {
            std::cout << "  🗑️ [డిస్ట్రక్టర్] మూవ్డ్ మ్యాట్రిక్స్ (No-op).\n";
        }
    }

    // 3. Copy Constructor (Deep Copy)
    MatrixEngine(const MatrixEngine& other) : rows(other.rows), cols(other.cols), data(nullptr) {
        allocateMemory();
        for (size_t i = 0; i < rows; ++i) {
            for (size_t j = 0; j < cols; ++j) {
                data[i][j] = other.data[i][j];
            }
        }
        std::cout << "  📋 [డీప్ కాపీ కన్‌స్ట్రక్టర్] " << rows << "x" << cols << " క్లోన్ చేయబడింది.\n";
    }

    // 4. Move Constructor (Zero-Copy Transfer)
    MatrixEngine(MatrixEngine&& other) noexcept
        : rows(other.rows), cols(other.cols), data(other.data) {
        other.data = nullptr;
        other.rows = 0;
        other.cols = 0;
        std::cout << "  ⚡ [MOVE కన్‌స్ట్రక్టర్] మ్యాట్రిక్స్ పాయింటర్లు మెరుపు వేగంతో బదిలీ చేయబడ్డాయి!\n";
    }

    // 5. Copy Assignment Operator
    MatrixEngine& operator=(const MatrixEngine& other) {
        if (this == &other) return *this; // Self-assignment check
        releaseMemory();
        rows = other.rows;
        cols = other.cols;
        allocateMemory();
        for (size_t i = 0; i < rows; ++i) {
            for (size_t j = 0; j < cols; ++j) {
                data[i][j] = other.data[i][j];
            }
        }
        std::cout << "  📝 [Copy Assignment] అసైన్‌మెంట్ డీప్ కాపీ జరిగింది.\n";
        return *this;
    }

    void set(size_t r, size_t c, double val) {
        if (r < rows && c < cols && data != nullptr) data[r][c] = val;
    }

    void display() const {
        if (data == nullptr) {
            std::cout << "  [ఖాళీ మ్యాట్రిక్స్ - Data was Moved]\n";
            return;
        }
        std::cout << "  మ్యాట్రిక్స్ డేటా (" << rows << "x" << cols << "):\n";
        for (size_t i = 0; i < rows; ++i) {
            std::cout << "    [ ";
            for (size_t j = 0; j < cols; ++j) {
                std::cout << data[i][j] << " ";
            }
            std::cout << "]\n";
        }
    }
};

int main() {
    std::cout << "=======================================================================\n";
    std::cout << "🧮 [HIGH-PERFORMANCE MATRIX RAII & RULE OF FIVE ENGINE]\n";
    std::cout << "=======================================================================\n";

    {
        MatrixEngine m1(2, 3);
        m1.set(0, 0, 1.5);
        m1.set(0, 1, 2.5);
        m1.set(1, 2, 9.9);
        m1.display();

        // డీప్ కాపీ పరీక్ష
        MatrixEngine m2 = m1;
        m2.set(0, 0, 99.0); // m1 మారకూడదు
        std::cout << "\nm2 మార్చిన తర్వాత m1 ని పరిశీలించండి (డీప్ కాపీ నిరూపణ):\n";
        m1.display();

        // Move Semantics పరీక్ష (Zero Copy)
        std::cout << "\nMove Constructor పరీక్ష:\n";
        MatrixEngine m3 = std::move(m1);
        std::cout << "\nm3 (Moved-in):\n";
        m3.display();
        std::cout << "m1 (Moved-out):\n";
        m1.display();
    } // స్కోప్ ముగియగానే అన్నీ లీక్-ఫ్రీగా డిస్ట్రక్ట్ అవుతాయి!

    std::cout << "=======================================================================\n";
    std::cout << "✅ జీరో మెమరీ లీక్స్‌తో రూల్ ఆఫ్ ఫైవ్ ఎగ్జిక్యూషన్ విజయవంతమైంది!\n";
    std::cout << "=======================================================================\n";
    return 0;
}