C పాయింటర్లు: బేసిక్స్, మెమరీ అడ్రస్లు & Dereferencing (*, &)

#include <stdio.h>

int main() {
    int age = 25;
    double salary = 75000.50;
    char grade = 'A';

    // పాయింటర్లు
    int *pAge = &age;
    double *pSalary = &salary;
    char *pGrade = &grade;

    printf("=== వేరియబుల్స్ & వాటి మెమరీ చిరునామాలు (%p ఫార్మాట్) ===\n");
    printf("age విలువ: %d        | మెమరీ అడ్రస్: %p\n", age, (void*)pAge);
    printf("salary విలువ: %.2f | మెమరీ అడ్రస్: %p\n", salary, (void*)pSalary);
    printf("grade విలువ: %c         | మెమరీ అడ్రస్: %p\n", grade, (void*)pGrade);

    printf("\n=== అన్ని రకాల పాయింటర్ల మెమరీ సైజు (sizeof) ===\n");
    printf("sizeof(int*)    = %zu బైట్లు\n", sizeof(pAge));
    printf("sizeof(double*) = %zu బైట్లు\n", sizeof(pSalary));
    printf("sizeof(char*)   = %zu బైట్లు\n", sizeof(pGrade));

    return 0;
}

#include <stdio.h>

int main() {
    int target = 100;
    int *ptr = &target; // ptr ఇప్పుడు target యొక్క మెమరీ అడ్రస్ ని పట్టుకుంది

    printf("ప్రారంభ విలువ: target = %d\n", target);

    // *ptr ద్వారా అసలైన వేరియబుల్ లోని విలువను సవరిస్తున్నాం!
    *ptr = 250;

    printf("సవరించిన తర్వాత: target = %d (మారిపోయింది!)\n", target);
    printf("పాయింటర్ ద్వారా చదివిన విలువ: *ptr = %d\n", *ptr);

    return 0;
}

#include <stdio.h>

int main() {
    int arr[3] = {10, 20, 30};
    int *p = &arr[0]; // మొదటి ఎలిమెంట్ అడ్రస్

    printf("ప్రారంభ అడ్రస్ p       = %p (arr[0] = %d)\n", (void*)p, *p);
    p = p + 1; // 4 బైట్లు ముందుకు దూకుతుంది!
    printf("p + 1 తర్వాత అడ్రస్ p  = %p (arr[1] = %d)\n", (void*)p, *p);
    p = p + 1; // మరో 4 బైట్లు ముందుకు దూకుతుంది!
    printf("p + 1 తర్వాత అడ్రస్ p  = %p (arr[2] = %d)\n", (void*)p, *p);

    return 0;
}

#include <stdio.h>
#include <stddef.h>

int main() {
    int numbers[] = {100, 200, 300, 400, 500};

    int *ptrStart = &numbers[0]; // ఇండెక్స్ 0
    int *ptrEnd = &numbers[4];   // ఇండెక్స్ 4

    // రెండు పాయింటర్ల మధ్య దూరం
    ptrdiff_t diff = ptrEnd - ptrStart;

    printf("ptrStart అడ్రస్: %p\n", (void*)ptrStart);
    printf("ptrEnd అడ్రస్  : %p\n", (void*)ptrEnd);
    printf("రెండు పాయింటర్ల మధ్య ఎలిమెంట్స్ సంఖ్య: %td\n", diff);

    return 0;
}

#include <stdio.h>

void printValue(void *ptr, char type) {
    if (type == 'i') {
        // int* గా టైప్ కాస్ట్ చేసి డిరిఫరెన్స్ చేస్తున్నాం
        printf("ఇంటిజర్ విలువ: %d\n", *(int*)ptr);
    } else if (type == 'f') {
        // float* గా టైప్ కాస్ట్
        printf("ఫ్లోట్ విలువ: %.2f\n", *(float*)ptr);
    } else if (type == 'c') {
        // char* గా టైప్ కాస్ట్
        printf("క్యారెక్టర్ విలువ: %c\n", *(char*)ptr);
    }
}

int main() {
    int n = 42;
    float pi = 3.14159f;
    char ch = 'Z';

    printValue(&n, 'i');
    printValue(&pi, 'f');
    printValue(&ch, 'c');

    return 0;
}

#include <stdio.h>

int main() {
    int value = 777;
    int *ptr1 = &value; // ptr1 -> value అడ్రస్
    int **ptr2 = &ptr1; // ptr2 -> ptr1 అడ్రస్ (డబుల్ పాయింటర్!)

    printf("value విలువ        = %d\n", value);
    printf("*ptr1 ద్వారా విలువ  = %d\n", *ptr1);
    printf("**ptr2 ద్వారా విలువ = %d (రెండుసార్లు డీరిఫరెన్స్!)\n", **ptr2);

    return 0;
}

#include <stdio.h>

// ఏ మెమరీ బ్లాక్‌నైనా బైట్-బై-బైట్ హెక్సాడెసిమల్‌లో ప్రింట్ చేసే ఇన్‌స్పెక్టర్
void dumpMemory(const void *startAddr, size_t numBytes) {
    // 1 బైట్ చొప్పున చదవడానికి unsigned char* కి టైప్ కాస్ట్ చేస్తున్నాం
    const unsigned char *bytePtr = (const unsigned char*)startAddr;

    printf("====================================================\n");
    printf("   RAM మెమరీ ఇన్‌స్పెక్టర్ (Raw Byte Hex Dumper)\n");
    printf("====================================================\n");
    printf("ప్రారంభ మెమరీ అడ్రస్: %p  | మొత్తం బైట్లు: %zu\n", startAddr, numBytes);
    printf("----------------------------------------------------\n");
    printf("ఆఫ్‌సెట్ | మెమరీ అడ్రస్        | హెక్స్ విలువ | క్యారెక్టర్\n");
    printf("----------------------------------------------------\n");

    for (size_t i = 0; i < numBytes; i++) {
        unsigned char b = bytePtr[i];
        // ముద్రించదగిన అక్షరమా కాదా అని చెక్ చేయడం
        char printable = (b >= 32 && b <= 126) ? b : '.';

        printf("+%02zu    | %p | 0x%02X       | '%c'\n",
               i, (void*)&bytePtr[i], b, printable);
    }
    printf("====================================================\n\n");
}

int main() {
    // 1. ఒక ఇంటిజర్ వేరియబుల్ మెమరీని పరీక్షిద్దాం (Little-Endian ఆర్కిటెక్చర్)
    int secretCode = 0x12345678;
    printf("1. ఇంటిజర్ వేరియబుల్ RAM లేఅవుట్ (0x12345678):\n");
    dumpMemory(&secretCode, sizeof(secretCode));

    // 2. ఒక స్ట్రింగ్ మెమరీ లేఅవుట్‌ను పరీక్షిద్దాం
    char message[] = "Mana C 2026";
    printf("2. స్ట్రింగ్ వేరియబుల్ RAM లేఅవుట్ ("Mana C 2026"):\n");
    dumpMemory(message, sizeof(message));

    return 0;
}