పాయింటర్లు, అర్రేస్, Double Pointers & కాల్‌బ్యాక్స్

అడ్వాన్స్‌డ్ C ప్రోగ్రామింగ్‌లో పాయింటర్లు మరియు అర్రేల సమన్వయం అనేది సాఫ్ట్‌వేర్ ఆర్కిటెక్ట్‌లకు అత్యంత కీలకమైన ఆయుధం. ఈ అధ్యాయంలో కవర్ చేయబడే ప్రధానాంశాలు:

• అర్రే-పాయింటర్ అంతర్గత బంధం: arr[i] == *(arr + i) గణిత సమానత్వం మరియు i[arr] వింత ప్రవర్తన.
• అర్రే వర్సెస్ పాయింటర్ కీలక తేడాలు: కాన్స్టాంట్ పాయింటర్ రీ-అసైన్‌మెంట్ పరిమితులు మరియు sizeof వ్యత్యాసాలు.
• అర్రే ఆఫ్ పాయింటర్స్ (Array of Pointers - int *arr[]): పాయింటర్ల వరుస మరియు ర్యాగ్డ్ అర్రేస్ (Ragged Arrays).
• డబుల్ పాయింటర్లు (Double Pointers - **ptr): పాయింటర్ యొక్క మెమరీ అడ్రస్‌ను పట్టుకునే లెవల్-2 ఇండైరెక్షన్.
• ఫంక్షన్లలో పాయింటర్ మోడిఫికేషన్: ఫంక్షన్ లోపల కాలర్ యొక్క పాయింటర్‌ను మార్చడానికి డబుల్ పాయింటర్లు ఎందుకు తప్పనిసరి?
• కమాండ్ లైన్ ఆర్గుమెంట్స్ (Command-Line Arguments): argc మరియు argv (అర్రే ఆఫ్ స్ట్రింగ్స్ char**) విశ్లేషణ.
• సమగ్ర తులనాత్మక పట్టిక: *arr[] (అర్రే ఆఫ్ పాయింటర్స్) vs (*arr)[] (పాయింటర్ టు యాన్ అర్రే).
• ఫంక్షన్ పాయింటర్లు (Function Pointers): కోడ్ సెగ్మెంట్‌లో ఫంక్షన్ల మెమరీ అడ్రస్‌లు మరియు సింటాక్స్ డీకోడింగ్.
• కాల్‌బ్యాక్ ఫంక్షన్స్ (Callback Architecture): లైబ్రరీలకు ఫంక్షన్లను పాస్ చేయడం మరియు C స్టాండర్డ్ qsort() ఇంజిన్.
• డైనమిక్ 2D అర్రేస్ పరిచయం: డబుల్ పాయింటర్లతో రన్‌టైమ్ గ్రిడ్ నిర్మాణం.
• సమగ్ర రియల్ వరల్డ్ ప్రాజెక్ట్: ప్లగ్-అండ్-ప్లే ఫంక్షన్ పాయింటర్ మ్యాథమెటికల్ క్యాలిక్యులేటర్ ఇంజిన్.
• బిగినర్స్ చేసే టాప్ 5 అడ్వాన్స్‌డ్ తప్పులు: బ్రాకెట్స్ మిస్సింగ్, డబుల్ పాయింటర్ అన్‌ఇనిషియలైజ్డ్ సెగ్‌ఫాల్ట్స్.
• స్వీయ మూల్యాంకన క్విజ్: 5 లోతైన విశ్లేషణాత్మక ప్రశ్నలు & గేట్ ఎగ్జామ్ కాన్సెప్ట్స్.

C లాంగ్వేజ్‌లో ఒక ప్రాథమిక సూత్రం ఉంది: "An array name evaluates to the address of its first element." (అర్రే పేరు అనగా దాని మొదటి ఎలిమెంట్ యొక్క బేస్ అడ్రస్ &arr[0]). మీరు స్క్వేర్ బ్రాకెట్లతో రాసే ఇండెక్సింగ్ సింటాక్స్ కంపైలర్ కోసం కేవలం ఒక పాయింటర్ అరిథ్‌మెటిక్ మాత్రమే:

కూడిక అనేది స్థిత్యంతర ధర్మాన్ని (Commutative Property: $A + B = B + A$) పాటిస్తుంది కాబట్టి:

#include <stdio.h>

int main() {
    int arr[4] = {10, 20, 30, 40};

    // ఈ 4 పద్ధతులు పూర్తిగా ఒకే ఒక్క విలువను ఇస్తాయి!
    printf("1. సాధారణ ఇండెక్సింగ్ arr[2]   = %d\n", arr[2]);
    printf("2. పాయింటర్ నోటేషన్ *(arr + 2) = %d\n", *(arr + 2));
    printf("3. తిరగరాసిన పాయింటర్ *(2 + arr) = %d\n", *(2 + arr));
    printf("4. విచిత్రమైన ఇండెక్సింగ్ 2[arr]    = %d (పూర్తిగా చెల్లుతుంది!)\n", 2[arr]);

    return 0;
}

అర్రే పేరు పాయింటర్‌లా ప్రవర్తించినప్పటికీ, అర్రే మరియు పాయింటర్ ఒకటి కావు! వాటి మధ్య రెండు భారీ సాంకేతిక వ్యత్యాసాలు ఉన్నాయి:

సాధారణ అర్రే సంఖ్యలను దాచుకుంటే, అర్రే ఆఫ్ పాయింటర్స్ మెమరీ చిరునామాలను (Pointers) ఒక వరుసలో నిల్వ చేస్తుంది. వేర్వేరు పొడవులు గల స్ట్రింగ్స్‌ను మెమరీ వేస్ట్ కాకుండా నిల్వ చేయడానికి ఇది అద్భుతంగా పనిచేస్తుంది:

#include <stdio.h>

int main() {
    // 4 స్ట్రింగ్ పాయింటర్ల అర్రే (Array of 4 char pointers)
    const char *districts[] = {
        "హైదరాబాద్",
        "విశాఖపట్నం",
        "విజయవాడ",
        "వరంగల్"
    };

    printf("=== అర్రే ఆఫ్ పాయింటర్స్ డిస్‌ప్లే ===\n");
    for (int i = 0; i < 4; i++) {
        printf("జిల్లా #%d: %s (అడ్రస్: %p)\n", i + 1, districts[i], (void*)districts[i]);
    }

    return 0;
}

ఒక పాయింటర్ కూడా RAM లో ఉండే సాధారణ వేరియబుల్ మాత్రమే కాబట్టి దానికి కూడా ఒక మెమరీ అడ్రస్ ఉంటుంది. ఆ పాయింటర్ యొక్క అడ్రస్‌ను పట్టుకునే పాయింటర్‌ను డబుల్ పాయింటర్ (**ptr) అంటారు.

డబుల్ పాయింటర్ ఎప్పుడు అవసరం?

ఒక ఫంక్షన్ లోపల సాధారణ వేరియబుల్ విలువను మార్చడానికి మనం సింగిల్ పాయింటర్ (&x) పాస్ చేస్తాం కదా? అదే విధంగా, ఒక ఫంక్షన్ లోపల ఒక పాయింటర్ పట్టుకున్న అడ్రస్‌నే మార్చాల్సి వస్తే, ఆ పాయింటర్ యొక్క అడ్రస్‌ను (డబుల్ పాయింటర్ &ptr) పాస్ చేయాలి!

#include <stdio.h>

int numA = 100;
int numB = 200;

// ఫంక్షన్ లోపల పాయింటర్‌ను numA నుండి numB కి మారుస్తున్నాం
void changeTarget(int **doublePtr) {
    *doublePtr = &numB; // కాలర్ యొక్క పాయింటర్ అడ్రస్ మార్చబడింది!
}

int main() {
    int *myPtr = &numA;
    printf("ఫంక్షన్ కాల్ కి ముందు: *myPtr = %d (numA)\n", *myPtr);

    changeTarget(&myPtr); // పాయింటర్ అడ్రస్ (&myPtr) ని పాస్ చేస్తున్నాం

    printf("ఫంక్షన్ కాల్ తర్వాత : *myPtr = %d (numB కి మారింది!)\n", *myPtr);
    return 0;
}

మనం టెర్మినల్‌లో gcc main.c -o app అని కమాండ్స్ రన్ చేస్తాం కదా? ఇక్కడ main.c, -o, app అనేవి కమాండ్ లైన్ ఆర్గుమెంట్స్. C ప్రోగ్రామ్‌లు టెర్మినల్ నుండి ఇన్‌పుట్ అందుకోవడానికి main() ఫంక్షన్‌కు రెండు పారామీటర్లు ఉంటాయి:

• int argc (Argument Count): టెర్మినల్ నుండి పాస్ చేసిన మొత్తం పదాల సంఖ్య (ప్రోగ్రామ్ పేరుతో సహా, ఎల్లప్పుడూ ≥ 1).
• char *argv[] (Argument Vector): ఆ పదాల స్ట్రింగ్ పాయింటర్ల అర్రే (డబుల్ పాయింటర్ char**).

#include <stdio.h>

int main(int argc, char *argv[]) {
    printf("=== కమాండ్ లైన్ ఆర్గుమెంట్స్ అనలిటిక్స్ ===\n");
    printf("మొత్తం ఆర్గుమెంట్ల సంఖ్య (argc) = %d\n", argc);

    for (int i = 0; i < argc; i++) {
        printf("argv[%d] = %s\n", i, argv[i]);
    }

    return 0;
}

C ఇంటర్వ్యూలలో అడిగే అత్యంత కఠినమైన బ్రాకెట్ ప్రిసిడెన్స్ ప్రశ్న:

కంప్యూటర్ RAM లో కేవలం వేరియబుల్స్ మాత్రమే కాదు; మనం రాసిన ఫంక్షన్ల మెషీన్ కోడ్ కూడా ఒక మెమరీ అడ్రస్ లోనే నిల్వ ఉంటుంది (Code Segment / Text Segment)! ఆ ఫంక్షన్ యొక్క మెమరీ చిరునామాను పట్టుకునే పాయింటర్‌ను ఫంక్షన్ పాయింటర్ (Function Pointer) అంటారు!

ఫంక్షన్ పాయింటర్ సింటాక్స్ అనాటమీ:

#include <stdio.h>

int add(int a, int b) { return a + b; }
int multiply(int a, int b) { return a * b; }

int main() {
    // ఫంక్షన్ పాయింటర్ డిక్లరేషన్
    int (*mathFunc)(int, int);

    // 1. add ఫంక్షన్ అడ్రస్ ని అసైన్ చేస్తున్నాం
    mathFunc = add;
    printf("add ఫంక్షన్ మెమరీ అడ్రస్: %p\n", (void*)mathFunc);
    printf("mathFunc(10, 20) ఫలితం = %d\n", mathFunc(10, 20));

    // 2. రన్‌టైమ్‌లో multiply ఫంక్షన్‌కి మారుస్తున్నాం!
    mathFunc = multiply;
    printf("multiply మెమరీ అడ్రస్   : %p\n", (void*)mathFunc);
    printf("mathFunc(10, 20) ఫలితం = %d\n", mathFunc(10, 20));

    return 0;
}

ఒక ఫంక్షన్‌కు మరొక ఫంక్షన్‌ను పారామీటర్‌గా పంపడాన్ని కాల్‌బ్యాక్ (Callback) అంటారు. C స్టాండర్డ్ లైబ్రరీలోని ప్రసిద్ధ qsort() అల్గారిథమ్ దీనికి అత్యుత్తమ ఉదాహరణ. సంఖ్యలను అసెండింగ్ లేదా డిసెండింగ్ ఆర్డర్‌లో ఎలా సార్ట్ చేయాలో మనం ఒక కాల్‌బ్యాక్ ఫంక్షన్ ద్వారా qsort కు అందిస్తాం:

#include <stdio.h>
#include <stdlib.h>

// qsort కోసం కంపారేటర్ కాల్‌బ్యాక్ ఫంక్షన్
int compareAscending(const void *a, const void *b) {
    int valA = *(const int*)a;
    int valB = *(const int*)b;
    return valA - valB; // పాజిటివ్ అయితే స్వాప్ చేస్తుంది
}

int main() {
    int arr[] = {64, 25, 12, 22, 11};
    int n = sizeof(arr) / sizeof(arr[0]);

    printf("సార్టింగ్ చేయడానికి ముందు: ");
    for (int i = 0; i < n; i++) printf("%d ", arr[i]);
    printf("\n");

    // qsort కు compareAscending ఫంక్షన్ పాయింటర్‌ను కాల్‌బ్యాక్‌గా పాస్ చేస్తున్నాం
    qsort(arr, n, sizeof(int), compareAscending);

    printf("సార్టింగ్ చేసిన తర్వాత   : ");
    for (int i = 0; i < n; i++) printf("%d ", arr[i]);
    printf("\n");

    return 0;
}

సాధారణ 2D అర్రేలలో రోస్ మరియు కాలమ్స్ సంఖ్య కంపైల్-టైమ్‌లోనే స్థిరంగా ఉండాలి. కానీ డబుల్ పాయింటర్లు (int **matrix) మరియు malloc() ఉపయోగించి యూజర్ కోరిన సైజుతో రన్‌టైమ్‌లో ఫ్లెక్సిబుల్ 2D గ్రిడ్‌లను నిర్మించవచ్చు. దీనిని మనం Phase 05 లో డైనమిక్ మెమరీతో కలిపి మరింత లోతుగా నేర్చుకుంటాం.

ఇప్పటివరకు నేర్చుకున్న ఫంక్షన్ పాయింటర్లు మరియు కాల్‌బ్యాక్స్ ఉపయోగించి ఒక ఎక్స్‌టెన్సిబుల్ ప్లగ్-అండ్-ప్లే మ్యాథమెటికల్ కంప్యూట్ ఇంజిన్ (Compute Engine) నిర్మిద్దాం. కోర్ ఇంజిన్ కోడ్‌ను మార్చకుండానే భవిష్యత్తులో కొత్త ఆపరేషన్లను జోడించవచ్చు:

#include <stdio.h>

// ఫంక్షన్ పాయింటర్ టైప్‌డెఫ్ (Function Signature)
typedef double (*MathOperation)(double, double);

// ఆపరేషన్లు
double opAdd(double a, double b) { return a + b; }
double opSubtract(double a, double b) { return a - b; }
double opPower(double base, double exp) {
    double res = 1.0;
    for (int i = 0; i < (int)exp; i++) res *= base;
    return res;
}

// కోర్ ఎగ్జిక్యూటర్ ఇంజిన్ (కాల్‌బ్యాక్ ద్వారా రన్ అవుతుంది)
void executeOperation(const char *opName, MathOperation func, double x, double y) {
    double result = func(x, y); // ఫంక్షన్ పాయింటర్ ద్వారా ఇన్వొకేషన్!
    printf("⚙️ [%-10s] ఇన్పుట్: (%.1f, %.1f) ➔ ఫలితం = %.2f\n", opName, x, y, result);
}

int main() {
    printf("====================================================\n");
    printf("   మనా ప్లగ్-అండ్-ప్లే కంప్యూట్ ఇంజిన్ (2026 Engine)\n");
    printf("====================================================\n");

    // రన్‌టైమ్‌లో వేర్వేరు ఫంక్షన్లను కాల్‌బ్యాక్‌లుగా పంపుతున్నాం
    executeOperation("కూడిక", opAdd, 45.0, 15.0);
    executeOperation("తీసివేత", opSubtract, 100.0, 35.0);
    executeOperation("ఘాతం (Power)", opPower, 2.0, 8.0);

    printf("====================================================\n");
    return 0;
}

ఈ పాఠంలోని లోతైన అంశాలను క్రింది 5 ప్రాక్టికల్ ప్రశ్నల ద్వారా పరీక్షించుకోండి: