- main(){
int a=2,*f1,*f2;
f1=f2=&a;
*f2+=*f2+=a+=2.5;
printf("\n%d %d %d",a,*f1,*f2);
}
Answer:
16 16 16
Explanation:
f1 and f2 both refer to the
same memory location a. So changes through f1 and f2 ultimately affects only
the value of a.
- main(){
char *p="GOOD";
char a[ ]="GOOD";
printf("\n sizeof(p) =
%d, sizeof(*p) = %d, strlen(p) = %d", sizeof(p), sizeof(*p), strlen(p));
printf("\n sizeof( = %d, strlen( = %d", sizeof(,
strlen();
}
Answer:
sizeof(p) = 2, sizeof(*p) = 1, strlen(p) = 4
sizeof( = 5, strlen( = 4
Explanation:
sizeof(p) => sizeof(char*) => 2
sizeof(*p) => sizeof(char) => 1
Similarly,
sizeof( => size of the character array => 5
When sizeof operator is
applied to an array it returns the sizeof the array and it is not the same as
the sizeof the pointer variable. Here the sizeof( where a is the character
array and the size of the array is 5 because the space necessary for the
terminating NULL character should also be taken into account.
- #define DIM( array, type) sizeof(array)/sizeof(type)
main(){
int arr[10];
printf(“The dimension of the
array is %d”, DIM(arr, int));
}
Answer:
10
Explanation:
The size of integer array of 10 elements is 10 *
sizeof(int). The macro expands to sizeof(arr)/sizeof(int) => 10 *
sizeof(int) / sizeof(int) => 10.
- int DIM(int array[]) {
return
sizeof(array)/sizeof(int );
}
main(){
int arr[10];
printf(“The dimension of the
array is %d”, DIM(arr));
}
Answer:
1
Explanation:
Arrays cannot be passed to
functions as arguments and only the pointers can be passed. So the argument is
equivalent to int * array (this is one of the very few places where [] and *
usage are equivalent). The return statement becomes, sizeof(int *)/ sizeof(int)
that happens to be equal in this case.
main(){
- static int a[3][3]={1,2,3,4,5,6,7,8,9};
int i,j;
static *p[]={a,a+1,a+2};
for(i=0;i<3;i++){
for(j=0;j<3;j++)
printf("%d\t%d\t%d\t%d\n",*(*(p+i)+j),
*(*(j+p)+i),*(*(i+p)+j),*(*(p+j)+i));
}
}
Answer:
1
1 1 1
2
4 2 4
3 7 3
7
4
2 4 2
5
5 5 5
6 8 6
8
7
3 7 3
8
6 8 6
9 9 9
9
Explanation:
*(*(p+i)+j) is equivalent to p[i][j].
- main(){
void swap();
int x=10,y=8;
swap(&x,&y);
printf("x=%d y=%d",x,y);
}
void swap(int *a, int *b){
*a ^= *b, *b ^= *a, *a ^= *b;
}
Answer:
x=10 y=8
Explanation:
Using ^ like this is a way
to swap two variables without using a temporary variable and that too in a
single statement.
Inside main(), void swap();
means that swap is a function that may take any number of arguments (not no
arguments) and returns nothing. So this doesn’t issue a compiler error by the
call swap(&x,&y); that has two arguments.
This convention is
historically due to pre-ANSI style (referred to as Kernighan and Ritchie style)
style of function declaration. In that style, the swap function will be defined
as follows,
void swap()
int *a, int *b{
*a ^= *b, *b ^= *a, *a ^= *b;
}
where the arguments follow
the (). So naturally the declaration for swap will look like, void swap() which
means the swap can take any number of arguments.
- main(){
int i = 257;
int *iPtr = &i;
printf("%d %d", *((char*)iPtr),
*((char*)iPtr+1) );
}
Answer:
1 1
Explanation:
The integer value 257 is
stored in the memory as, 00000001 00000001, so the individual bytes are taken
by casting it to char * and get printed.
- main(){
int i = 258;
int *iPtr = &i;
printf("%d %d", *((char*)iPtr), *((char*)iPtr+1)
);
}
Answer:
2 1
Explanation:
The integer value 257 can be
represented in binary as, 00000001 00000001. Remember that the INTEL machines
are ‘small-endian’ machines. Small-endian means that the lower order bytes are
stored in the higher memory addresses and the higher order bytes are stored in
lower addresses. The integer value 258 is stored in memory as: 00000001
00000010.
- main(){
int i=300;
char *ptr = &i;
*++ptr=2;
printf("%d",i);
}
Answer:
556
Explanation:
The integer value 300 in binary notation is: 00000001 00101100. It
is stored in memory (small-endian) as:
00101100 00000001. Result of the expression *++ptr = 2 makes the memory
representation as: 00101100 00000010. So the integer corresponding to it is
00000010 00101100 => 556.
- main()
{
char * str =
"hello";
char * ptr = str;
char least = 127;
while (*ptr++)
least = (*ptr<least )
?*ptr :least;
printf("%d",least);
}
Answer:
0
Explanation:
After ‘ptr’ reaches the end
of the string the value pointed by ‘str’ is ‘\0’. So the value of ‘str’ is less
than that of ‘least’. So the value of ‘least’ finally is 0.
No comments:
Post a Comment