C Aptitude Part VII

Note : All the programs are tested under Turbo C/C++ compilers.
It is assumed that,
Programs run under DOS environment,
The underlying machine is an x86 system,
Program is compiled using Turbo C/C++ compiler.
The program output may depend on the information based on this assumptions
(for example sizeof(int) == 2 may be assumed).
---------------------------------------------------------------------------------------------------------------------------------------
Predict the output or error(s) for the following:
---------------------------------------------------------------------------------------------------------------------------------------
126)
int aaa() {printf(―Hi‖);}
int bbb(){printf(―hello‖);}
iny ccc(){printf(―bye‖);}
main()
{
int ( * ptr[3]) ();
ptr[0] = aaa;
54ptr[1] = bbb;
ptr[2] =ccc;
ptr[2]();
}
Answer:
bye
Explanation:
int (* ptr[3])() says that ptr is an array of pointers to functions that takes
no arguments and returns the type int. By the assignment ptr[0] = aaa; it
means that the first function pointer in the array is initialized with the
address of the function aaa. Similarly, the other two array elements also
get initialized with the addresses of the functions bbb and ccc. Since ptr[2]
contains the address of the function ccc, the call to the function ptr[2]() is
same as calling ccc(). So it results in printing "bye".
---------------------------------------------------------------------------------------------------------------------------------------
127)
main()
{
int i=5;
printf(―%d‖,i=++i ==6);
}
Answer:
1
Explanation:
The expression can be treated as i = (++i==6), because == is of higher
precedence than = operator. In the inner expression, ++i is equal to 6
yielding true(1). Hence the result.
---------------------------------------------------------------------------------------------------------------------------------------
128)
main()
{
char p[ ]="%d\n";
p[1] = 'c';
printf(p,65);
}
Answer:
A
Explanation:
Due to the assignment p[1] =  ̳c‘ the string becomes, ―%c\n‖. Since this
string becomes the format string for printf and ASCII value of 65 is  ̳A‘,
the same gets printed.
---------------------------------------------------------------------------------------------------------------------------------------
129)
void ( * abc( int, void ( *def) () ) ) ();
Answer::
abc is a ptr to a function which takes 2 parameters .(a). an integer
variable.(b).
a ptrto a funtion which returns void. the return type of the
function is void.
Explanation:
Apply the clock-wise rule to find the result.
---------------------------------------------------------------------------------------------------------------------------------------
130) main()
{
while (strcmp(―some‖,‖some\0‖))
printf(―Strings are not equal\n‖);
}
Answer:
No output
Explanation:
Ending the string constant with \0 explicitly makes no difference. So
―some‖ and ―some\0‖ are equivalent. So, strcmp returns 0 (false) hence
breaking out of the while loop.
---------------------------------------------------------------------------------------------------------------------------------------
131) 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.
---------------------------------------------------------------------------------------------------------------------------------------
132)
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.
---------------------------------------------------------------------------------------------------------------------------------------
133) 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.
---------------------------------------------------------------------------------------------------------------------------------------
134) 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.
---------------------------------------------------------------------------------------------------------------------------------------
135) 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;
136)
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'
a="Hi"
: legal
: illegal
3. Same as 1.
---------------------------------------------------------------------------------------------------------------------------------------
137)
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.
---------------------------------------------------------------------------------------------------------------------------------------
138)
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.
---------------------------------------------------------------------------------------------------------------------------------------
139)
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.
---------------------------------------------------------------------------------------------------------------------------------------
140)
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.
---------------------------------------------------------------------------------------------------------------------------------------
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
2
3
4
1
4
7
2
1
2
3
4
1
4
7
2
615
6
7
8
9
5
8
3
6
9
5
6
7
8
9
5
8
3
6
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.
---------------------------------------------------------------------------------------------------------------------------------------
151)
#include <stdio.h>
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.
---------------------------------------------------------------------------------------------------------------------------------------
152) Declare an array of N pointers to functions returning pointers to functions
returning pointers to characters?
Answer:
(char*(*)( )) (*ptr[N])( );
---------------------------------------------------------------------------------------------------------------------------------------
153) 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.month,
&student.dob.year);
&student.dob.day,
}
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.
---------------------------------------------------------------------------------------------------------------------------------------
154)
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.
---------------------------------------------------------------------------------------------------------------------------------------
155) 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.
---------------------------------------------------------------------------------------------------------------------------------------
156) Is there any difference between the two declarations,
1. int foo(int *arr[]) and
2. int foo(int *arr[2])
Answer:
No
Explanation:
Functions can only pass pointers and not arrays. The numbers that are
allowed inside the [] is just for more readability. So there is no difference
between the two declarations.
---------------------------------------------------------------------------------------------------------------------------------------
157) What is the subtle error in the following code segment?
void fun(int n, int arr[])
{
int *p=0;
int i=0;
while(i++<n)
p = &arr[i];
*p = 0;
}
Answer & Explanation:
If the body of the loop never executes p is assigned no address. So
p remains NULL where *p =0 may result in problem (may rise to
runtime error ―NULL pointer assignment‖ and terminate the
program).
---------------------------------------------------------------------------------------------------------------------------------------
158) What is wrong with the following code?
int *foo()
{
int *s = malloc(sizeof(int)100);
assert(s != NULL);
return s;
}
Answer & Explanation:
assert macro should be used for debugging and finding out bugs. The
check s != NULL is for error/exception handling and for that assert
shouldn‘t be used. A plain if and the corresponding remedy statement has
to be given.
---------------------------------------------------------------------------------------------------------------------------------------
159) What is the hidden bug with the following statement?
assert(val++ != 0);
Answer & Explanation:
Assert macro is used for debugging and removed in release version. In
assert, the experssion involves side-effects. So the behavior of the code
becomes different in case of debug version and the release version thus
leading to a subtle bug.
Rule to Remember:
Don‟t use expressions that have side-effects in assert statements.
---------------------------------------------------------------------------------------------------------------------------------------
160) void main()
{
int *i = 0x400; // i points to the address 400
*i = 0;
// set the value of memory location pointed by i;
}
Answer:
Undefined behavior
Explanation:
The second statement results in undefined behavior because it points to
some location whose value may not be available for modification. This
66type of pointer in which the non-availability of the implementation of the
referenced location is known as 'incomplete type'.
---------------------------------------------------------------------------------------------------------------------------------------