141) main()
{
extern
i;
printf("%d\n",i);
{
int
i=20;
printf("%d\n",i);
}
}
Answer:
Linker
Error : Unresolved external symbol i
Explanation:
The
identifier i is available in the inner block and so using extern has no use in
resolving it.
142) 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.
143) 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(a) = %d,
strlen(a) = %d", sizeof(a), strlen(a));
}
Answer:
sizeof(p) = 2,
sizeof(*p) = 1, strlen(p) = 4
sizeof(a) = 5, strlen(a) = 4
Explanation:
sizeof(p)
=> sizeof(char*) => 2
sizeof(*p) => sizeof(char) =>
1
Similarly,
sizeof(a) => 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(a) 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.
144) #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.
145) 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.
146) 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].
147) 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.
148) 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.
149) 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.
150) 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.
No comments:
Post a Comment