Dangling pointer :-
Which pointer variable pointing to an inactive or dead location, it is called a dangling pointer.
Function pointer :
Which pointer variable holds the address of function, it is called function pointer
Advantage:-
By using function pointers in C, we can pass a fun 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 of 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 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 into 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 retuning 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 a auto variable which is constructed with in the abc() function so when the control will pass to main() function it will destroyed
- In above program ptr is called dangling pointer because it is pointing to inactive or dead location
- The solution of the dangling pointer is in place of creating auto reconsidered to create static variable because 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.
- 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();
}
No comments:
Post a Comment
commnet here