Predict the output or
error(s) for the following:
63. main()
{
int i=4,j=7;
j = j || i++
&& printf("YOU CAN");
printf("%d %d", i, j);
}
Answer:
4 1
Explanation:
The boolean expression needs to be evaluated only till the truth value of the
expression is not known. j is not equal to zero itself means that the
expression’s truth value is 1. Because it is followed by || and true ||
(anything) => true where (anything) will not be evaluated. So the remaining
expression is not evaluated and so the value of i remains the same.
Similarly when && operator is involved in an expression, when any of the
operands become false, the whole expression’s truth value becomes false and
hence the remaining expression will not be evaluated.
false &&
(anything) => false where (anything) will not be evaluated.
64. main()
{
register int a=2;
printf("Address of a = %d",&a);
printf("Value of a = %d",a);
}
Answer:
Compier Error: '&' on register variable
Rule to Remember:
& (address of ) operator cannot be applied on register variables.
65. main()
{
float i=1.5;
switch(i)
{
case 1: printf("1");
case 2: printf("2");
default : printf("0");
}
}
Answer:
Compiler Error: switch expression not integral
Explanation:
Switch statements can be applied only to integral types.
66. 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.
67. 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.
68. 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.
69. #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.
70. 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.
71. 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].
Page Numbers :
1
2
3
4
5
6
7
8
9
10
11
12
