Call by Value vs Call by Reference & మెమరీ పాయింటర్స్

#include <stdio.h>

void modifyValue(int n) {
    printf("  [ఫంక్షన్ లోపల - ప్రారంభం] n = %d, మెమరీ అడ్రస్ = %p\n", n, (void*)&n);
    n = n + 100; // కేవలం లోకల్ కాపీ మాత్రమే పెరుగుతుంది!
    printf("  [ఫంక్షన్ లోపల - ముగింపు]   n = %d, మెమరీ అడ్రస్ = %p\n", n, (void*)&n);
}

int main() {
    int score = 50;
    printf("[main లోపల - కాల్ చేయడానికి ముందు] score = %d, మెమరీ అడ్రస్ = %p\n", score, (void*)&score);

    modifyValue(score); // Call by Value!

    printf("[main లోపల - కాల్ చేసిన తర్వాత]    score = %d, మెమరీ అడ్రస్ = %p\n", score, (void*)&score);
    return 0;
}

#include <stdio.h>

// ❌ పనిచేయని బగ్గీ స్వాప్ ఫంక్షన్
void wrongSwap(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
    printf("  [wrongSwap లోపల] a = %d, b = %d (ఇక్కడ మారాయి!)\n", a, b);
}

int main() {
    int x = 10, y = 20;

    printf("స్వాప్ చేయడానికి ముందు: x = %d, y = %d\n", x, y);
    wrongSwap(x, y); // ❌ ఫెయిల్ అవుతుంది!
    printf("స్వాప్ చేసిన తర్వాత:    x = %d, y = %d (మారలేదు!)\n", x, y);

    return 0;
}

#include <stdio.h>

// ✅ విజయవంతంగా పనిచేసే సరైన స్వాప్ ఫంక్షన్
void trueSwap(int *ptrA, int *ptrB) {
    // 1. ptrA ఉన్న చిరునామాలోని విలువను తాత్కాలికంగా దాచు
    int temp = *ptrA;

    // 2. ptrB ఉన్న చిరునామాలోని విలువను ptrA చిరునామాలోకి కాపీ చేయి
    *ptrA = *ptrB;

    // 3. temp లో ఉన్న విలువను ptrB చిరునామాలోకి రాయి
    *ptrB = temp;

    printf("  [trueSwap లోపల] అడ్రస్ ఆధారంగా ఒరిజినల్ మెమరీ మార్చబడింది!\n");
}

int main() {
    int x = 10, y = 20;

    printf("స్వాప్ చేయడానికి ముందు: x = %d, y = %d\n", x, y);

    // వేరియబుల్స్ అడ్రస్‌లను (&x, &y) ఫంక్షన్‌కు పాస్ చేస్తున్నాం
    trueSwap(&x, &y);

    printf("స్వాప్ చేసిన తర్వాత:    x = %d, y = %d (విజయవంతంగా మారాయి!)\n", x, y);
    return 0;
}

#include <stdio.h>

// ఒకే ఫంక్షన్ నుండి Quotient మరియు Remainder రెండింటినీ రిటర్న్ చేద్దాం
int divide(int dividend, int divisor, int *quotient, int *remainder) {
    if (divisor == 0) {
        return 0; // సున్నా చేత భాగహారం నిషిద్ధం (విఫలం)
    }

    *quotient = dividend / divisor;  // మొదటి ఫలితం
    *remainder = dividend % divisor; // రెండవ ఫలితం
    return 1; // విజయం (Success flag)
}

int main() {
    int a = 29, b = 6;
    int q, r;

    printf("29 ని 6 చేత భాగిస్తున్నాం...\n");
    if (divide(a, b, &q, &r)) {
        printf("✅ భాగహారం సక్సెస్!\n");
        printf("   భాగఫలం (Quotient) = %d\n", q);
        printf("   శేషం (Remainder)  = %d\n", r);
    } else {
        printf("❌ ఎర్రర్: సున్నాతో భాగించలేము!\n");
    }

    return 0;
}

#include <stdio.h>

// const int *data అంటే: ఈ పాయింటర్ ద్వారా డేటాను చదవవచ్చే కానీ మార్చకూడదు!
void printConfiguration(const int *configValue) {
    printf("సిస్టమ్ కాన్ఫిగరేషన్ విలువ: %d\n", *configValue);

    // ఒకవేళ డెవలపర్ పొరపాటున ఇలా రాయడానికి ప్రయత్నిస్తే:
    // *configValue = 999;
    // కంపైలర్ వెంటనే: 'assignment of read-only location' అని ఎర్రర్ ఇచ్చి ఆపేస్తుంది!
}

int main() {
    int secretKey = 7788;
    printConfiguration(&secretKey);
    return 0;
}

#include <stdio.h>

int safelyIncrement(int *ptr) {
    // 🛡️ గార్డ్ క్లాజ్: పాయింటర్ NULL కాదా అని తనిఖీ చేయి!
    if (ptr == NULL) {
        printf("🚨 హెచ్చరిక: అక్రమ శూన్య పాయింటర్ (NULL Pointer) గుర్తించబడింది! సెగ్‌ఫాల్ట్ నివారించబడింది.\n");
        return -1; // విఫలమైనట్లు సంకేతం
    }

    (*ptr)++; // సురక్షితమైన ఇంక్రిమెంట్
    return 0; // విజయం
}

int main() {
    int counter = 10;
    int *validPtr = &counter;
    int *nullPtr = NULL; // ఎక్కడికీ పాయింట్ చేయని పాయింటర్

    safelyIncrement(validPtr);
    printf("చెల్లుబాటు అయ్యే పాయింటర్ ఇంక్రిమెంట్ అయింది: %d\n", counter);

    safelyIncrement(nullPtr); // ప్రోగ్రామ్ క్రాష్ అవ్వకుండా సురక్షితంగా రక్షించబడుతుంది!
    return 0;
}

#include <stdio.h>

// బ్యాంక్ ఫండ్ ట్రాన్స్‌ఫర్ ఫంక్షన్ (Call by Reference)
int transferFunds(double *fromAccount, double *toAccount, double amount) {
    // 1. సేఫ్టీ చెక్: పాయింటర్లు చెల్లుబాటు అయ్యేవేనా?
    if (fromAccount == NULL || toAccount == NULL) {
        printf("❌ ట్రాన్సాక్షన్ విఫలమైంది: ఖాతా పాయింటర్లు చెల్లవు!\n");
        return 0;
    }

    // 2. అమౌంట్ చెక్: బదిలీ మొత్తం పాజిటివ్‌గా ఉండాలి
    if (amount <= 0) {
        printf("❌ ట్రాన్సాక్షన్ విఫలమైంది: బదిలీ మొత్తం సున్నా లేదా నెగెటివ్ ఉండకూడదు!\n");
        return 0;
    }

    // 3. సరిపడా నిధులు ఉన్నాయా? (Insufficient Funds Check)
    if (*fromAccount < amount) {
        printf("❌ ట్రాన్సాక్షన్ విఫలమైంది: ఖాతాలో సరిపడా బ్యాలెన్స్ లేదు! (లభ్యత: రూ. %.2f)\n", *fromAccount);
        return 0;
    }

    // 4. అసలైన మెమరీ లొకేషన్లలో బ్యాలెన్స్‌లను అప్‌డేట్ చేయి
    *fromAccount -= amount; // పంపే వారి ఖాతా నుండి మినహాయింపు
    *toAccount += amount;   // అందుకునే వారి ఖాతాకు జమ

    printf("✅ ట్రాన్సాక్షన్ విజయవంతమైంది: రూ. %.2f బదిలీ చేయబడింది!\n", amount);
    return 1;
}

int main() {
    double rahulBalance = 25000.00; // రాహుల్ ఖాతా
    double snehaBalance = 8500.00;  // స్నేహ ఖాతా

    printf("==================================================\n");
    printf("   మనా బ్యాంకింగ్ కోర్ సిస్టమ్ (Fund Transfer Engine)\n");
    printf("==================================================\n");
    printf("బదిలీకి ముందు:\n");
    printf("  రాహుల్ బ్యాలెన్స్: రూ. %.2f\n", rahulBalance);
    printf("  స్నేహ బ్యాలెన్స్ : రూ. %.2f\n", snehaBalance);
    printf("--------------------------------------------------\n");

    // రాహుల్ ఖాతా నుండి స్నేహ ఖాతాకు రూ. 7,000 బదిలీ చేద్దాం
    printf("-> రాహుల్ నుండి స్నేహకు రూ. 7,000 బదిలీ చేస్తున్నాం...\n");
    transferFunds(&rahulBalance, &snehaBalance, 7000.00);

    printf("--------------------------------------------------\n");
    printf("బదిలీ తర్వాత:\n");
    printf("  రాహుల్ బ్యాలెన్స్: రూ. %.2f\n", rahulBalance);
    printf("  స్నేహ బ్యాలెన్స్ : రూ. %.2f\n", snehaBalance);
    printf("==================================================\n");

    return 0;
}