పాయింటర్లు & రిఫరెన్సెస్ (Pointers & References)

#include <iostream>

int main() {
    int age = 25;
    double price = 999.50;
    char rank = 'A';

    std::cout << "===== C++ Memory Addresses (RAM Examination) =====\n";
    std::cout << "age విలువ: " << age << " | RAM Address (&age): " << &age << "\n";
    std::cout << "price విలువ: " << price << " | RAM Address (&price): " << &price << "\n";
    // char వేరియబుల్ అడ్రస్ ప్రింట్ చేయాలంటే void* కు కాస్ట్ చేయాలి
    std::cout << "rank విలువ: " << rank << " | RAM Address (&rank): " << (void*)&rank << "\n";

    std::cout << "\nage ఆక్రమించిన సైజ్: " << sizeof(age) << " Bytes\n";
    std::cout << "price ఆక్రమించిన సైజ్: " << sizeof(price) << " Bytes\n";
    return 0;
}

#include <iostream>

int main() {
    int target = 42;
    int* ptr = ⌖ // ptr లో target యొక్క మెమరీ చిరునామా భద్రపరచబడింది

    std::cout << "target అసలు విలువ: " << target << "\n";
    std::cout << "target మెమరీ అడ్రస్ (&target): " << &target << "\n";
    std::cout << "ptr లో భద్రపరిచిన అడ్రస్: " << ptr << "\n";
    std::cout << "ptr చూపిస్తున్న విలువ (*ptr - Dereferencing): " << *ptr << "\n";
    std::cout << "ptr స్వంత మెమరీ అడ్రస్ (&ptr): " << &ptr << "\n";

    std::cout << "\n--- డీరిఫరెన్సింగ్ ద్వారా విలువను మార్చడం ---\n";
    *ptr = 999; // ptr ఉన్న అడ్రస్‌లోని విలువను 999 గా మారుస్తున్నాం!

    std::cout << "*ptr = 999 అమలు చేసిన తర్వాత target విలువ: " << target << "\n";
    return 0;
}

#include <iostream>

struct HeavyPayload {
    char data[10000];
    double matrices[50][50];
};

int main() {
    char c = 'Z';
    int i = 100;
    double d = 3.14159;
    HeavyPayload hp;

    char* pChar = &c;
    int* pInt = &i;
    double* pDouble = &d;
    HeavyPayload* pHp = &hp;

    std::cout << "===== CPU Architecture & Pointer Sizes =====\n";
    std::cout << "sizeof(char*):         " << sizeof(pChar) << " Bytes\n";
    std::cout << "sizeof(int*):          " << sizeof(pInt) << " Bytes\n";
    std::cout << "sizeof(double*):       " << sizeof(pDouble) << " Bytes\n";
    std::cout << "sizeof(HeavyPayload*): " << sizeof(pHp) << " Bytes\n";

    std::cout << "\nఅసలు డేటా సైజులు (Pointed Values):\n";
    std::cout << "sizeof(char):         " << sizeof(*pChar) << " Byte\n";
    std::cout << "sizeof(HeavyPayload): " << sizeof(*pHp) << " Bytes\n";
    return 0;
}

#include <iostream>
#include <cstddef> // ptrdiff_t కొరకు

int main() {
    int numbers[] = {10, 20, 30, 40, 50};
    int* p = numbers; // numbers[0] అడ్రస్ కు సమానం

    std::cout << "===== Pointer Arithmetic Demonstration =====\n";
    std::cout << "మొదటి ఎలిమెంట్: " << *p << " (అడ్రస్: " << p << ")\n";

    p++; // తర్వాతి int కు జంప్ (4 బైట్లు ముందుకు)
    std::cout << "p++ తర్వాత ఎలిమెంట్: " << *p << " (అడ్రస్: " << p << ")\n";

    p += 2; // మరో 2 స్థానాలు ముందుకు
    std::cout << "p += 2 తర్వాత ఎలిమెంట్: " << *p << " (అడ్రస్: " << p << ")\n";

    int* start = &numbers[0];
    int* end = &numbers[4];
    ptrdiff_t distance = end - start;

    std::cout << "\nరెండు పాయింటర్ల మధ్య దూరం (end - start): " << distance << " ఎలిమెంట్స్\n";
    return 0;
}

#include <iostream>

void inspect(int value) {
    std::cout << "-> inspect(int) పిలువబడింది: " << value << "\n";
}

void inspect(int* ptr) {
    if (ptr == nullptr) {
        std::cout << "-> inspect(int*) పిలువబడింది: [Safe NULLPTR Pointer]\n";
    } else {
        std::cout << "-> inspect(int*) పిలువబడింది: వాల్యూ = " << *ptr << "\n";
    }
}

int main() {
    std::cout << "===== Modern C++ nullptr Type Safety =====\n";
    inspect(100);       // inspect(int) పిలుస్తుంది
    inspect(nullptr);   // ఖచ్చితంగా inspect(int*) నే పిలుస్తుంది!

    int* safePtr = nullptr;
    if (safePtr != nullptr) {
        std::cout << *safePtr << "\n";
    } else {
        std::cout << "safePtr సురక్షితంగా nullptr వద్ద ఉంది. క్రాష్ నివారించబడింది!\n";
    }
    return 0;
}

#include <iostream>

int main() {
    int bankBalance = 50000;
    int& alias = bankBalance; // alias అనేది bankBalance యొక్క ప్రత్యక్ష మారుపేరు

    std::cout << "bankBalance: " << bankBalance << " (అడ్రస్: " << &bankBalance << ")\n";
    std::cout << "alias:       " << alias << " (అడ్రస్: " << &alias << ")\n";

    std::cout << "\n--- alias ద్వారా విలువను సవరించడం ---\n";
    alias += 15000; // alias లో మార్పు చేస్తే నేరుగా bankBalance మారుతుంది!

    std::cout << "కొత్త bankBalance: " << bankBalance << "\n";
    std::cout << "గమనించండి: &bankBalance మరియు &alias ఖచ్చితంగా ఒకే అడ్రస్!\n";
    return 0;
}

#include <iostream>

int main() {
    int a = 10;
    int b = 20;

    // 1. Pointer to CONST data
    const int* p1 = &a;
    // *p1 = 15; // కంపైలర్ ఎర్రర్! డేటా రీడ్-ఓన్లీ
    p1 = &b;      // సవ్యమైనది! వేరే అడ్రస్‌ను సూచించవచ్చు

    // 2. CONST Pointer to mutable data
    int* const p2 = &a;
    *p2 = 99;     // సవ్యమైనది! విలువను సవరించవచ్చు
    // p2 = &b;   // కంపైలర్ ఎర్రర్! పాయింటర్ అడ్రస్ మార్చలేము

    // 3. CONST Pointer to CONST data
    const int* const p3 = &a;
    // *p3 = 100; // కంపైలర్ ఎర్రర్!
    // p3 = &b;   // కంపైలర్ ఎర్రర్!

    std::cout << "a యొక్క తాజా విలువ: " << a << "\n";
    std::cout << "*p1 (b చూపిస్తోంది): " << *p1 << "\n";
    return 0;
}

#include <iostream>
#include <string>

// 1. Pass by Value (పూర్తి కాపీ అవుతుంది - స్లో)
void modifyByValue(int x) {
    x += 100;
}

// 2. Pass by Pointer (అడ్రస్ పాస్ అవుతుంది - అసలు విలువ మారుతుంది)
void modifyByPointer(int* ptr) {
    if (ptr != nullptr) {
        *ptr += 100;
    }
}

// 3. Pass by Reference (మారుపేరు - క్లీన్ & ఫాస్ట్)
void modifyByReference(int& ref) {
    ref += 100;
}

// 4. Pass by Const Reference (భారీ ఆబ్జెక్టులకు జీరో-కాపీ రీడ్-ఓన్లీ)
void printBigData(const std::string& hugeText) {
    std::cout << "టెక్స్ట్ సైజు: " << hugeText.length() << " అక్షరాలు (Zero-Copy!)\n";
}

int main() {
    int val = 10;

    modifyByValue(val);
    std::cout << "modifyByValue తర్వాత: " << val << " (మార్పు లేదు - 10)\n";

    modifyByPointer(&val);
    std::cout << "modifyByPointer తర్వాత: " << val << " (మారింది - 110)\n";

    modifyByReference(val);
    std::cout << "modifyByReference తర్వాత: " << val << " (మారింది - 210)\n";

    std::string report = "Our Compiler Modern C++ Masterclass 2026";
    printBigData(report);
    return 0;
}

#include <iostream>

enum class DataType { INT, DOUBLE, CHAR };

void printGeneric(void* ptr, DataType type) {
    if (ptr == nullptr) return;

    switch (type) {
        case DataType::INT: {
            int* intPtr = static_cast<int*>(ptr);
            std::cout << "Generic Int వాల్యూ: " << *intPtr << "\n";
            break;
        }
        case DataType::DOUBLE: {
            double* dblPtr = static_cast<double*>(ptr);
            std::cout << "Generic Double వాల్యూ: " << *dblPtr << "\n";
            break;
        }
        case DataType::CHAR: {
            char* chrPtr = static_cast<char*>(ptr);
            std::cout << "Generic Char వాల్యూ: " << *chrPtr << "\n";
            break;
        }
    }
}

int main() {
    int num = 404;
    double pi = 3.14159;
    char code = 'K';

    printGeneric(&num, DataType::INT);
    printGeneric(&pi, DataType::DOUBLE);
    printGeneric(&code, DataType::CHAR);
    return 0;
}

#include <iostream>

// ప్రమాదకరమైన కోడ్ - ఫంక్షన్ లోకల్ స్టాక్ అడ్రస్ రిటర్న్ చేయడం తప్పు!
int* dangerousFunction() {
    int localVal = 500;
    return &localVal; // ⚠️ WARNING: localVal ఫంక్షన్ ముగియగానే నశిస్తుంది!
}

int main() {
    int* badPtr = dangerousFunction();
    // *badPtr ని యాక్సెస్ చేయడం Undefined Behavior! మెమరీ కరప్ట్ కావచ్చు.
    std::cout << "డాంగ్లింగ్ పాయింటర్‌ను నివారించడానికి Modern C++ లో స్మార్ట్ పాయింటర్లు లేదా వాల్యూ రిటర్న్స్ వాడాలి!\n";
    return 0;
}

#include <iostream>
#include <cstdint>
#include <cstring>
#include <iomanip>

// హార్డ్‌వేర్ నెట్‌వర్క్ ప్యాకెట్ హెడర్ లేఅవుట్ (Packed Struct)
#pragma pack(push, 1)
struct TelemetryPacketHeader {
    uint16_t magic;         // 0xABCD (2 Bytes)
    uint32_t packetSeq;     // సీక్వెన్స్ నంబర్ (4 Bytes)
    uint16_t sensorId;      // సెన్సార్ ఐడీ (2 Bytes)
    float    temperature;   // సెన్సార్ ఉష్ణోగ్రత (4 Bytes)
    uint32_t payloadLength; // పేలోడ్ పొడవు (4 Bytes)
};
#pragma pack(pop)

// పాయింటర్లు & రిఫరెన్సులతో జీరో-కాపీ ప్యాకెట్ అనలైజర్ క్లాస్
class BinaryStreamParser {
public:
    static void parseStream(const uint8_t* rawBuffer, size_t totalBytes) {
        std::cout << "====================================================================\n";
        std::cout << "📡 [HIGH-FREQUENCY ZERO-COPY BINARY PACKET PARSER ENGINE]\n";
        std::cout << "మొత్తం స్వీకరించిన బైట్లు: " << totalBytes << " Bytes\n";
        std::cout << "====================================================================\n";

        const uint8_t* currentPtr = rawBuffer;
        const uint8_t* endPtr = rawBuffer + totalBytes;
        size_t packetCount = 0;

        while (currentPtr + sizeof(TelemetryPacketHeader) <= endPtr) {
            // జీరో కాపీ: మెమరీ బఫర్‌ను నేరుగా Struct పాయింటర్‌గా రీఇంటర్‌ప్రెట్ చేస్తున్నాం!
            const TelemetryPacketHeader* header = reinterpret_cast<const TelemetryPacketHeader*>(currentPtr);

            // Magic Byte చెక్ (0xABCD)
            if (header->magic != 0xABCD) {
                std::cout << "❌ చెల్లని మ్యాజిక్ బైట్: " << std::hex << header->magic << ". స్ట్రీమ్ సింక్ లోపం!\n";
                break;
            }

            packetCount++;
            std::cout << "\n[ప్యాకెట్ #" << packetCount << " పరిశీలన]:\n";
            std::cout << "  - మ్యాజిక్ ఐడెంటిఫైయర్ : 0x" << std::hex << header->magic << std::dec << "\n";
            std::cout << "  - ప్యాకెట్ సీక్వెన్స్  : " << header->packetSeq << "\n";
            std::cout << "  - సెన్సార్ ఐడీ        : 0x" << std::hex << header->sensorId << std::dec << "\n";
            std::cout << "  - కొలిచిన ఉష్ణోగ్రత  : " << std::fixed << std::setprecision(2) << header->temperature << " °C\n";
            std::cout << "  - పేలోడ్ పరిమాణం      : " << header->payloadLength << " Bytes\n";

            // పాయింటర్ అరిథ్‌మెటిక్ ద్వారా పేలోడ్ లొకేషన్‌కు కదలడం
            const uint8_t* payloadPtr = currentPtr + sizeof(TelemetryPacketHeader);
            std::cout << "  - పేలోడ్ టెక్స్ట్ డేటా: \"";
            for (uint32_t i = 0; i < header->payloadLength; ++i) {
                std::cout << static_cast<char>(*(payloadPtr + i));
            }
            std::cout << "\"\n";

            // తర్వాతి ప్యాకెట్‌కు పాయింటర్‌ను జంప్ చేయడం (Header Size + Payload Length)
            currentPtr += sizeof(TelemetryPacketHeader) + header->payloadLength;
        }

        std::cout << "\n====================================================================\n";
        std::cout << "✅ మొత్తం " << packetCount << " టెలిమెట్రీ ప్యాకెట్లు సున్నా మెమరీ కాపీలతో విజయవంతంగా పార్స్ చేయబడ్డాయి!\n";
        std::cout << "====================================================================\n";
    }
};

int main() {
    // నెట్‌వర్క్ సాకెట్ నుండి వచ్చినట్లుగా ఒక సిమ్యులేటెడ్ బైనరీ స్ట్రీమ్ బఫర్
    uint8_t networkBuffer[512] = {0};
    uint8_t* writePtr = networkBuffer;

    // ప్యాకెట్ 1 రాత (ISRO Rocket Telemetry 1)
    TelemetryPacketHeader p1;
    p1.magic = 0xABCD;
    p1.packetSeq = 1001;
    p1.sensorId = 0x55AA;
    p1.temperature = 48.75f;
    const char* msg1 = "STAGE-1 BOOSTER IGNITION NORMAL";
    p1.payloadLength = static_cast<uint32_t>(std::strlen(msg1));

    std::memcpy(writePtr, &p1, sizeof(TelemetryPacketHeader));
    writePtr += sizeof(TelemetryPacketHeader);
    std::memcpy(writePtr, msg1, p1.payloadLength);
    writePtr += p1.payloadLength;

    // ప్యాకెట్ 2 రాత (ISRO Rocket Telemetry 2)
    TelemetryPacketHeader p2;
    p2.magic = 0xABCD;
    p2.packetSeq = 1002;
    p2.sensorId = 0x55AB;
    p2.temperature = 74.20f;
    const char* msg2 = "MAX-Q VELOCITY 1250 M/S CRITICAL";
    p2.payloadLength = static_cast<uint32_t>(std::strlen(msg2));

    std::memcpy(writePtr, &p2, sizeof(TelemetryPacketHeader));
    writePtr += sizeof(TelemetryPacketHeader);
    std::memcpy(writePtr, msg2, p2.payloadLength);
    writePtr += p2.payloadLength;

    size_t totalBytesWritten = writePtr - networkBuffer;

    // పార్సర్ కాల్ (Const Pointer గా పాస్ చేస్తున్నాం)
    BinaryStreamParser::parseStream(networkBuffer, totalBytesWritten);

    return 0;
}