Pointers Introduction

15.1. Introduction

సాధారణమైన variable లానే, Pointer కూడా ఒక variable, కానీ దీనికి address మాత్రమే (assign) ఇవ్వగలం. ఒక variable declaration statement లో variable కు ముందు asterisk(*) ఉంటే దానిని pointer type variable అని చెప్పినట్లు అర్ధం వస్తుంది. ఉదాహరణకు.
int *number;
char *ch;
float *gnumber;

పైన చూపిన విధంగా, pointer variablesలో types ఉంటాయి. ఏ టైప్ అయినా, వాటికి మనం address మాత్రమే ఇచ్చేవీలుంటుంది. Pointer definition ఇంకా లోతుగా చెప్పాలంటే, దానికి మనం allocate అయిన memory address మాత్రమే ఇవ్వగలం. మనకు నచ్చిన నంబరును ఇవ్వలేం,'0' ను తప్ప. అంతే కాకుండా, ఒక pointer variableకు అదే టైప్ variable address మాత్రమే ఇవ్వాలి. ఉదాహరణకు,
int k=10, *ptr;
ptr=&k;

ఇక్కడ, variable k addressను pointer variable ptr కు ఇచ్చాం. ఇది valid ఆపరేషన్. అప్పుడు, ptrను kకు pointer అని అంటారు. k విలువను ptr ద్వారా కూడా access చెయ్యవచ్చు. అంటే, ptrకు "indirection operator" ( asterisk) ను జోడిస్తే, *ptr అనేది k అవుతుంది. ఎక్కడైతే kను వాడాలో అక్కడ *ptrను వాడవచ్చు. ఉదాహరణకు, kకు 7 ఇవ్వాలంటే, *ptr = 7; అని రాయవచ్చు. అప్పుడు, pointer ptr విలువ ఏ memoryని point చేస్తుందో (అది ఇప్పుడు k యొక్క memory), దానిలో 7 స్టోర్ చేస్తుంది. ఈ కింది printf statement, k విలువని *ptr ద్వారా ప్రింట్ చేస్తుంది.
printf("%d\n",*ptr);

ముఖ్య గమనిక - Declaration statementsలో ఒక variableకు ముందు * ఉంటే అది pointer type అని, ఇంకేదైనా statementలో ఒక pointer variableకు ముందు * ఉంటే, indirection operator అని అంటారు. అది ఆ pointer variable point చేస్తున్న memoryలో ఉన్న విలువను indicate చేస్తుంది.

Example 1: ఈ కింది ప్రోగ్రాం ద్వారా పైన చెప్పిన conceptsను ఎలా ఉపయోగించాలో చూద్దాం.
#include
int main()
{
int *p, i=20;
p=&i;
i++;
printf("%d %d\n", i, *p);
i=i+10;
printf("%d %d\n", i, *p);
*p=*p+10;
printf("%d %d\n", i, *p);
(*p)++;
printf("%d %d\n", i, *p);
printf("Enter a value for i\n");
scanf("%d", p);
printf("%d %d\n", i, *p);
return 0;
}

పైన ఇచ్చిన టేబుల్ , పై ప్రోగ్రాంఎలా పని చేస్తుందో ఉదాహరణకు కొన్ని డమ్మీ విలువలను తీసుకుని చూపిస్తుంది. ఇక్కడ memory addressలు అన్నీ డమ్మీ విలువలు.

Output:
21 21
31 31
41 41
42 42
Enter a value for i
566
566 566

Example 2: ఈ ప్రోగ్రాంలో pointer variable విలువను ఇంకొక pointer variableకు ఇవ్వవచ్చు అని చెప్పడానికి.
#include
void main()
{
int I=10,J=17, *p, *q;
p=&I;
q=p;
printf(“%d %d\n”, *p, *q);
p=&J;
printf(“%d %d\n”, *p , *q);
}

పైన ఇచ్చిన ప్రోగ్రాంను రన్ చేసినప్పుడు కంప్యూటరు మీద ఈ విధంగా ఉంటుంది.

15.2. Pointer to Pointer

ఒక pointer variableకు కూడా pointer variableను declare చెయ్యవచ్చు. ఈ విధంగా చేయడానికి మనకు pointer to a pointer టైప్ variable, అంటే, int **a టైప్ వాడాల్సి ఉంటుంది. ఈ టైప్ variable లో ఒక integer టైప్ pointer variable యొక్క addressను స్టోర్ చేయవచ్చు.

పై code fragmentలో రెండు integer variables a, b లను, ఓ integer pointer, p, ఒక integer point to pointer, q ను declare చేసాం. తర్వాత, a కు 7 ఇచ్చాం, a address ను p కు ఇచ్చాం. ఆ తర్వాత, qకు p addressను ఇచ్చాం. తర్వాత, b=*p execute అయినప్పుడు, a విలువ, 7, bకు ఇవ్వబడినది. అలాగే, *p=5 statement వలన, a విలువ 5 అయింది. (b విలువ మారలేదు, అది ఇంకా 7). ఆ తర్వాత, **q=3 statement execute అవడంతో a విలువ 3 అవుతుంది. ఎలా అంటే, p లో a address ఉంది, అలాగే q లో p యొక్క address ఉంది. అందువలన **q లో *q అంటే p అవుతుంది. ఇప్పుడు మరొక indirection అప్లై చేస్తే, *p, అంటే a అని అర్ధం.

ఈ pointer to pointer conceptను ఎంతవరకైనా పొడిగించవచ్చు. ఉదాహరణకు,
int **a;
int ***a;
int ****a;

Example 3: ఈ ప్రోగ్రాం ఫలితం ఏమిటో చూడండి.
#include
int main()
{
int *p, i=10;
p=&i;
printf("\n%d %d\n",*p, *&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&*&i);
return 0;
}

Output: 10 10.

ఒక variable i address &i, అలాగే, *&i అంటే i విలువ. పై ప్రోగ్రాంలో దీనిని recursively వాడాం. పైన ఇచ్చిన entire expression i విలువను తెలుపుతుంది.

15.3. Passing Pointers to Functions

ఒక functionలోపలికి address పంపుతున్నామని చెప్పడానికి formal argument ముందు * ఈ కింది విధంగా పెడతాం.
void xyz(int *x);
అంటే, పై function ను call చేస్తున్నపుడు ఒక integer variable address పంపాలి, ఈ function లో x ఒక pointer type variable. ఈ function లో x pointer variableను వాడి ,అది point చేస్తున్న addressలో ఏం చేసినా అది మనం పంపిన actual argument మీద జరుగుతుంది. దానినే Passing by address అని అంటారు.

గమనిక: ఒక function ను call చేసినప్పుడు అందులో ఉన్న formal argumentsకు, లోపల declare చేసే variable (scratch variables)కు మెమొరీ allocate అవుతుంది. Functionలోనుంచి రిటర్న్ అవగానే ఈ మెమొరీ de-allocate అవుతుంది. ఈ allocate చేసిన మెమొరీని actiactivation frame లేదా activation record లేదా stack frame లేదా stack record ಅನಿ అంటారు.

Example 4: ఈ ప్రోగ్రాంలో, mainలో ఉన్న i అనే variable addressను xyz function కు పంపిస్తున్నాం. ఆ address లో xyz functionలో 100 స్టోర్ చేస్తున్నాం. Function లోపలి నుంచి రాగానే x విలువ ను main లో ప్రింట్ చేస్తే 100 గా ప్రింట్ అవుతుంది. అలా Functionలో చేసిన మార్పు mainలో 'i' variable లో మనం చూడగలుగుతున్నాం.
#include
void xyz(int *x)
{
*x=100; /* We are storing 100 in the memory refered by x*/
}
int main()
{
int i=10;
printf("Value of i before function call=%d\n", i);
xyz(&i);/* The function prototype indicates that we have to send address. We are sending the address of i*/
printf("Value of i before function call=%d\n", i);
return 0;
}

Function Call చేయకముందు memory ఇలా ఉంటుంది.

ఇప్పుడు, xyz(&i); అనేది execute అయితే memory ఇలా ఉంటుంది.

ఇప్పుడు *x=100; అనేది execute అయితే 100ను 0023FF74లో స్టోర్ చేస్తున్నాం, అంటే i లో.

Function లో నుంచి control main లోపలికి రాగానే memory ఈ కింది విధంగా ఉంటుంది:

పైన ఇచ్చిన ప్రోగ్రాంను రన్ చేసినప్పుడు కంప్యూటరు మీద ఈ విధంగా ఉంటుంది.

Example 5: ఈ ప్రోగ్రాంలో ఒక integer variable address తీసుకొని అందులో ఉండే విలువను reverse చేసే function ను రాసి దానిని main నుంచి call చేయడం ఎలాగో చూద్దాం.
#include
void REV(int *x)
{
int n, s=0;
n=*x;
while(n)
{
s=s*10 + n%10;
n=n/10;
}
*x=s;
}
int main()
{
int i;
printf(“Enter a Number\n”);
scanf(“%d”, &i);
REV(&i);
printf(“Value of the number after function call=%d\n”, i);
return 0;
}
పైన ఇచ్చిన ప్రోగ్రాంను రన్ చేసినప్పుడు కంప్యూటరు మీద ఈ విధంగా ఉంటుంది.

Example 6: రెండు సంఖ్యలున్న అంకెను తీసుకుని దాని అంకెల స్థానాలను తారుమారు చేసి call చేసే విధంగా ఒక ప్రోగ్రాం రాయండి.

#include
void swap(int *a, int *b)
{
int T;
T=*a;
*a=*b;
*b=T;
}
int main()
{
int i, j;
printf(“Enter two Numbers\n”);
scanf(“%d%d”, &i, &j);
swap(&i,&j);
printf(“Values after function call=%d %d\n”, i, j);
return 0;
}
main program లో variables declare చేసిన తర్వాత memory content.

swap() function call చేసిన తర్వాత memory content. అంటే, i, j variables address లు a,b అనే variablesకు assign అవుతాయి.

T=*a; అనే statement execute చేసిన తర్వాత memory content. ఇక్కడ, pointer variable a పాయింట్ చేస్తున్న మెమొరీలో ఉన్న విలువ, అంటే 10, T కు assign అవుతుంది.

*a=*b; అనే statement execute చేసిన తర్వాత memory content. ఇక్కడ, pointer variable b పాయింట్ చేస్తున్న మెమొరీలో ఉన్న విలువ, అంటే 17, pointer variable a పాయింట్ చేస్తున్న మెమొరీలో ఉన్న విలువ lAలా అవుతుంది

*b=T; అనే statement execute చేసిన తర్వాత memory content. ఇక్కడ, pointer variable b పాయింట్ చేస్తున్న మెమొరీలో ఉన్న విలువ lAలాగా T, అంటే 10 అవుతుంది

swap() function lOలో నుంచి main లోకి వచ్చిన తర్వాత memory content.

ఇలాగా i, j అనే variables విలువలు exchange అవుతాయి.

పైన ఇచ్చిన ప్రోగ్రాంను రన్ చేసినప్పుడు కంప్యూటరు మీద ఈ విధంగా ఉంటుంది.

Example 7: ఇక్కడ రాసిన function ఒక 1-D integer arrayను తీసుకొని దాని elements average, maximum, minimum లను రిటర్న్ చేస్తుంది.
Solution: మనకు మూడు విలువలు ఈ function నుంచి రిటర్న్ అవ్వాలి. కనుక మనము array తో పాటూ మూడు variables addressలు కూడా main నుంచి పంపుతాం. Function లో ఆ address లో మనం రిటర్న్ చేయాలనుకున్న average, maximum, minimum లను స్టోర్ చేస్తాం. అలా మనకు కావలసిన మూడు విలువలు mainలో నుంచి వేటి addressలు పంపామో వాటిలోకి వస్తాయి.
void stat3(int a[], int n, int *X, int *Y, int *Z)
{
int I,s,max,min;
for(I=1,s=a[0],max=a[0],min=a[0];I s+=a[I];
if(max if(min>a[I])min=a[I];
}
/*storing the values to be returned in the addresses*/
*X=s/n; *X=max; *Z=min;
}
int main()
{
int N, a[10],I,A,B,C;

printf(“Enter number of elements \n”);
scanf(“%d”, &N);

/* reading elements into array */
printf(“Enter elements values \n”);
for(I=0;I stat3(a, N, &A, &B, &C);
printf(“Average=%d\nMaximum=%d\nMinimum=%d\n”, A,B,C);
return 0;
}