126.main(){
char str1[] = {‘s’,’o’,’m’,’e’};
char str2[] = {‘s’,’o’,’m’,’e’,’\0’};
while (strcmp(str1,str2))
printf(“Strings are not equal\n”);
}
Answer:
“Strings are not equal”
“Strings are not equal”
….
Explanation:
If a string constant is initialized explicitly with characters,
‘\0’ is not appended automatically to the string. Since str1 doesn’t have null
termination, it treats whatever the values that are in the following positions
as part of the string until it randomly reaches a ‘\0’. So str1 and str2 are
not the same, hence the result.
127.main(){
int i = 3;
for (;i++=0;) printf(“%d”,i);
}
Answer:
Compiler Error: Lvalue required.
Explanation:
As we know that increment operators return rvalues and hence it cannot appear on the left hand side
of an assignment operation.
128.void
main(){
int *mptr, *cptr;
mptr = (int*)malloc(sizeof(int));
printf(“%d”,*mptr);
int *cptr = (int*)calloc(sizeof(int),1);
printf(“%d”,*cptr);
}
Answer:
garbage-value 0
Explanation:
The memory space allocated by malloc is uninitialized, whereas
calloc returns the allocated memory space initialized to zeros.
129.void main(){
static int i;
while(i<=10)
(i>2)?i++:i--;
printf(“%d”, i);
}
Answer:
32767
Explanation:
Since i is static it is initialized to 0. Inside the while loop
the conditional operator evaluates to false, executing i--. This continues till
the integer value rotates to positive value (32767). The while condition
becomes false and hence, comes out of the while loop, printing the i value.
130.main(){
int i=10,j=20;
j = i, j?(i,j)?i:j:j;
printf("%d
%d",i,j);
}
Answer:
10 10
Explanation:
The Ternary operator ( ? : ) is equivalent for if-then-else
statement. So the question can be written as:
if(i,j){
if(i,j)
j = i;
else
j = j;
}
else
j = j;
131.1.
const char *a;
2.
char* const a;
3.
char const *a;
-Differentiate
the above declarations.
Answer:
1.
'const' applies to char * rather than 'a' ( pointer to a constant char )
*a='F' : illegal
a="Hi" : legal
2. 'const' applies to 'a'
rather than to the value of a (constant pointer to char )
*a='F' :
legal
a="Hi" : illegal
3. Same as 1.
132. main(){
int i=5,j=10;
i=i&=j&&10;
printf("%d
%d",i,j);
}
Answer:
1 10
Explanation:
The expression can be written as i=(i&=(j&&10)); The
inner expression (j&&10) evaluates to 1 because j==10. i is 5. i =
5&1 is 1. Hence the result.
133.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.
134.main(){
register int a=2;
printf("Address of a =
%d",&;
printf("Value of a = %d",;
}
Answer:
Compier Error: '&' on register variable
Rule
to Remember:
&
(address of ) operator cannot be applied on register variables.
135.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.
136.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.
137.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.
138.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.
139.#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.
140.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.
141.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].
142.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.
143.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.
144.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.
145.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.
146.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.
147.
Declare
an array of N pointers to functions returning pointers to functions
returning pointers to characters?
Answer:
(char*(*)( )) (*ptr[N])( );
148.main(){
struct student {
char name[30];
struct date dob;
}stud;
struct date{
int day,month,year;
};
scanf("%s%d%d%d",
stud.rollno, &student.dob.day, &student.dob.month, &student.dob.year);
}
Answer:
Compiler Error: Undefined structure date
Explanation:
Inside the struct definition of ‘student’ the member of type
struct date is given. The compiler doesn’t have the definition of date
structure (forward reference is not
allowed in C in this case) so it issues an error.
149.main(){
struct date;
struct student{
char name[30];
struct date dob;
}stud;
struct date{
int day,month,year;
};
scanf("%s%d%d%d",
stud.rollno, &student.dob.day, &student.dob.month,
&student.dob.year);
}
Answer:
Compiler Error: Undefined structure date
Explanation:
Only declaration of struct date is available inside the structure
definition of ‘student’ but to have a variable of type struct date the
definition of the structure is required.
150.
There
were 10 records stored in “somefile.dat” but the following program printed 11
names. What went wrong?
void main(){
struct student{
char name[30], rollno[6];
}stud;
FILE *fp = fopen(“somefile.dat”,”r”);
while(!feof(fp)) {
fread(&stud,
sizeof(stud), 1 , fp);
puts(stud.name);
}
}
Explanation:
fread reads 10 records and prints the names successfully. It will
return EOF only when fread tries to read another record and fails reading EOF
(and returning EOF). So it prints the last record again. After this only the
condition feof(fp) becomes false, hence comes out of the while loop.
0 comments:
Post a Comment