Dangling & Function pointers in C

Dangling pointer And Function pointer in C

Dangling pointer

Which pointer variable pointing to an inactive or dead location, it is called dangling pointer.

Function pointer

Which pointer variable holds the address of the function, it is called function pointer

Advantage 

By using function pointers in C, we can pass a f’n as an argument to another function  

• By using function pointers in C, it is possible to access or modify the local data of a function from outside.
• function pointer call 2 are faster than normal f’n call

syntax :  datatype*(*ptr)(); - non parameterized ex: int*(*ptr)(); datatype*(*ptr)(datatype);  - > parameterized ex : int*(*ptr)(int);

• Depends on the function pointer head only, we require to decide the parameterized or not parameterized function.

Written by Call by value, written by address :

• Whenever fun’s is returning value type data then it is called “written by value”
• Whenever a function is returning address type data then it is called written by address, i.e function returning pointer type.
• The basic advantage of return by address is we can modify or access the local data type of a function from outside.
• Whenever a function is returning an integer value the specify the return by address is we can modify or access local data of function from outside.
• Whenever a function is returning an integer value then specify the return type as an i.e function
• The basic function advantage of return by address is we can modify or access local data of a function from outside
• Whenever a function is returning an integer value then specify the return type as an int. i.e, function returning value(return by value ).
• Whenever a function is returning an integer variable address ( is we can Modi) then specify the return type as an int

i.e, ( function returning pointer (return by address)   int *abc() { int a=10; ++ a; return &a; } void main() { int *ptr; ptr = abc(); printf(“n value of a%d”, *ptr); }   o/p : value of a : 11(illegal)  

• According to storage classes of c, a is an auto variable that is constructed within the abc() function so when the control will pass to main() function it will be destroyed
• In above program, ptr is called dangling pointer because it is pointing to an inactive or dead location
• The solution of the dangling pointer is in place of creating auto reconsidered to create static variable because the lifetime of the static variable is entire the program.

int *xyz()

{ static int s=5; --s; return &s; } void main() { int *ptr ptr=xyz(); print=xyz(); printf(“n static data: %d”,*ptr);

o/p : static data : 4  

void abc()

{ printf(“welcome abc”); } void main() { void (*ptr)();       // function pointer ptr=&abc; ptr(); //abc(); }

o/p : welcome abc  

void abc()

{ printf(“welcome abc”); } void main() { void(*ptr)(); ptr=&abc; abc(); }

o/p : welcome abc  

int xyz (void)

{ int a=10; ++a; return a; }   void main() { int(*ptr)(void); int x; ptr=&xyz; x=ptr(); printf(“value of : %d”,x); }

o/p : value of x : 11  

int abc()

{ 
static int s=15; 
++s; 
return &s; 
} 
} 
void main() 
{ 
int*(*ptr)();         //    function pointer 
int *p;               //     pointer integer 
ptr=&abc; 
p=ptr(); int 
abc(int x) 
{ 
static  int s; 
s=++x; 
return &s; 
} 
void xyz(int i) 
{ 
printf(“n static data is xyz : %d”,i); 
} 
void fun ptr(int * myptr) 
{ 
myptr= 88; 
} 
void main() 
{
 int *(*ptr) (int); 
int +*p; 
int +a; 
ptr=&abc; 
p=ptr(10); 
xyz(ptr(20)); 
funptr(ptr(30)); 
a=*p; 
ptrinf(“n static data in main : %d”,a); 
static data in main 88.   35      
}

• Where ever the function is not returning only values then specify the return type as void.
• void means nothing i.e, return value

void abc() 
{ 
printf(“Hello abc”); 
} 
void main() 
{ 
abc(); 
}

o/p : Hello abc  

• If the function return type is void then it is possible to place empty return statement.
• From void() function when we are placing empty return statement then control will pass to back to the calling

void tex(long int no)

{

switch(no)

{

case 1 : printf (“one”);

break;

case 2 : printf (“two”);

break;

case 3 : printf (“three”);

break;

case 4 : printf (“four”);

break;

case 5 : printf (“five”);

break;

case 6 : printf (“six”);

break;

case 7 : printf (“seven”);

break;

case 8 : printf (“eight”);

break;

case 9 : printf (“nine”);

break;

case 10 : printf (“ten”);

break;

case 11 : printf (“eleven”);

break;

case 12 : printf (“twelve”);

break;

case 13 : printf (“thirteen”);

break;

case 14 : printf (“fourteen”);

break;

case 15 : printf (“fifteen”);

break;

case 16 : printf (“sixteen”);

break;

case 17 : printf (“seventeen”);

break;

case 18 : printf (“eighteen”);

break;

case 19 : printf (“nineteen”);

break;

case 20 : printf (“twenty”);

break;

case 30 : printf (“thirty”);

break;

case 40 : printf (“forty”);

break;

case 50 : printf (“fifty”);

break;

case 60 : printf (“sixty”);

break;

case 70 : printf (“seventy”);

break;

case 80 : printf (“eighty”);

break;

case 90 : printf (“ninety”);

break;

case 100 : printf (“hundred”);

break;

case 1000 : printf (“Thousand”);

break;

case 1000000 : printf (“Lakh”);

break;

case 10000000 : printf (“Crore”);

break;

}// end of switch

} // end of text.

void digittotx(long int n)

{

long int t;

if(n==0)

printf(“Zero”);

if(n>=10000000)

{

t=n/10000000;

if(t<=20)

text(t)

else

text(10000);

text(t%10);

}

text(10000000);

n=n%10000000;

}

if(n>=1-----)

{

t=n/100000;

if(t<=20)

{

text(t);

else

{

text(t/10*10);

text(t%10);

}
text(100000);
}

if(n>=1000)
{
t=n/1000;
if(t<=20)
text(t);
else
{
text(t/10*10);
text(t%10);
}
text(1000);
n=n%1000;
}
if(n>=100)
{
t=n/100;
text(t);
text(100);
n=n%100;
}
if(n<=20)
text(n);
else
{
text(n/10*10);
text(n%10);
}
void currency (long double rps)
{
long int r,p;
r=(long int)rps;
digittotxt(r);
printf(“Rupees“);
p=(rps-r)*100;
digittotxt(p);
printf(“paise”);
}
void main()
{
long double n;
clrscr();
printf(“Enter amount:”);
scanf(“%LF”,&n);
currency(n);
getch();

For an in-depth understanding of Pointers click on

• Pointers and their Rules in C Language
• Arguments in C
• Recursion in C
• Pointers to Pointer Architecture