(1) 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.
(2) 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.
(3) #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.
(4) Declare an array of N pointers to functions returning pointers to
functions returning pointers to characters?
Answer:
(char*(*)(
)) (*ptr[N])( );
(5) 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.
(6) 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.
(7) 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.
(8) 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.
(9) 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).
(10) 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.
(11) 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.
(12) 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 type of pointer in which the
non-availability of the implementation of the referenced location is known as
'incomplete type'.
(13) #define
assert(cond) if(!(cond)) \
(fprintf(stderr, "assertion failed: %s,
file %s, line %d \n",#cond,\
__FILE__,__LINE__), abort())
void main()
{
int i = 10;
if(i==0)
assert(i < 100);
else
printf("This statement becomes else for
if in assert macro");
}
Answer:
No output
Explanation:
The else part in which the
printf is there becomes the else for if in the assert macro. Hence nothing is
printed.
The solution is to use
conditional operator instead of if statement,
#define assert(cond)
((cond)?(0): (fprintf (stderr, "assertion failed: \ %s, file %s, line %d
\n",#cond, __FILE__,__LINE__), abort()))
Note:
However this problem of
“matching with nearest else” cannot be solved by the usual method of placing
the if statement inside a block like this,
#define assert(cond) { \
if(!(cond)) \
(fprintf(stderr, "assertion failed: %s,
file %s, line %d \n",#cond,\
__FILE__,__LINE__), abort()) \
}
(14) Is the
following code legal?
struct a
{
int x;
struct a b;
}
Answer:
No
Explanation:
Is it not legal for a
structure to contain a member that is of the same
type as in this case.
Because this will cause the structure declaration to be recursive without end.
(15) Is the
following code legal?
struct a
{
int x;
struct a *b;
}
Answer:
Yes.
Explanation:
*b is a pointer to type
struct a and so is legal. The compiler knows, the size of the pointer to a
structure even before the size of the structure
is determined(as you know
the pointer to any type is of same size). This type of structures is known as
‘self-referencing’ structure.
(16) Is the
following code legal?
typedef struct a
{
int x;
aType *b;
}aType
Answer:
No
Explanation:
The typename aType is not
known at the point of declaring the structure (forward references are not made
for typedefs).
(17) Is the
following code legal?
typedef struct a aType;
struct a
{
int x;
aType *b;
};
Answer:
Yes
Explanation:
The typename aType is known
at the point of declaring the structure, because it is already typedefined.
(18) Is the
following code legal?
void main()
{
typedef struct a aType;
aType someVariable;
struct a
{
int x;
aType *b;
};
}
Answer:
No
Explanation:
When
the declaration,
typedef struct a aType;
is encountered body of
struct a is not known. This is known as ‘incomplete types’.
(19) void
main()
{
printf(“sizeof (void *) = %d
\n“, sizeof( void *));
printf(“sizeof
(int *) = %d \n”, sizeof(int *));
printf(“sizeof
(double *) = %d \n”, sizeof(double *));
printf(“sizeof(struct
unknown *) = %d \n”, sizeof(struct unknown *));
}
Answer :
sizeof (void *) = 2
sizeof (int *) = 2
sizeof (double *) = 2
sizeof(struct unknown *)
= 2
Explanation:
The pointer to any type is
of same size.
(20) char
inputString[100] = {0};
To get string input from the
keyboard which one of the following is better?
1) gets(inputString)
2) fgets(inputString, sizeof(inputString), fp)
Answer & Explanation:
The second one is better
because gets(inputString) doesn't know the size of the string passed and so, if
a very big input (here, more than 100 chars) the charactes will be written past
the input string. When fgets is used with stdin performs the same operation as
gets but is safe.
(21) Which
version do you prefer of the following two,
1) printf(“%s”,str); // or the more curt one
2) printf(str);
Answer & Explanation:
Prefer the first one. If the
str contains any format characters like
%d then it will result in a subtle bug.
(22) void
main()
{
int i=10, j=2;
int *ip= &i, *jp =
&j;
int k = *ip/*jp;
printf(“%d”,k);
}
Answer:
Compiler Error: “Unexpected
end of file in comment started in line 5”.
Explanation:
The programmer intended to
divide two integers, but by the “maximum munch” rule, the compiler treats the
operator sequence / and * as /* which happens to be the starting of comment. To
force what is intended by the programmer,
int k = *ip/
*jp;
// give space
explicity separating / and *
//or
int k =
*ip/(*jp);
// put braces to
force the intention
will solve the
problem.
(23) void
main()
{
char ch;
for(ch=0;ch<=127;ch++)
printf(“%c %d \n“, ch, ch);
}
Answer:
Implementaion dependent
Explanation:
The char type may be signed
or unsigned by default. If it is signed then ch++ is executed after ch reaches
127 and rotates back to -128. Thus ch is always smaller than 127.
(24) Is this code legal?
int
*ptr;
ptr = (int *) 0x400;
Answer:
Yes
Explanation:
The
pointer ptr will point at the integer in the memory location 0x400.
(25) main()
{
char a[4]="HELLO";
printf("%s",a);
}
Answer:
Compiler
error: Too many initializers
Explanation:
The array a is of size 4 but
the string constant requires 6 bytes to get stored.
(26) main()
{
char a[4]="HELL";
printf("%s",a);
}
Answer:
HELL%@!~@!@???@~~!
Explanation:
The character array has the
memory just enough to hold the string “HELL” and doesnt have enough space to
store the terminating null character. So it prints the HELL correctly and
continues to print garbage values till it accidentally
comes across a NULL character.
(26) main()
{
int
a=10,*j;
void *k;
j=k=&a;
j++;
k++;
printf("\n
%u %u ",j,k);
}
Answer:
Compiler
error: Cannot increment a void pointer
Explanation:
Void pointers are generic
pointers and they can be used only when the type is not known and as an
intermediate address storage type. No pointer arithmetic can be done on it and
you cannot apply indirection operator (*) on void pointers.
(26) main()
{
extern
int i;
{
int i=20;
{
const volatile unsigned i=30;
printf("%d",i);
}
printf("%d",i);
}
printf("%d",i);
}
int i;
(27) Printf can
be implemented by using __________ list.
Answer:
Variable
length argument lists
(28) char *someFun()
{
char *temp = “string constant";
return temp;
}
int main()
{
puts(someFun());
}
Answer:
string constant
Explanation:
The program suffers no problem and gives the output correctly
because the character constants are stored in code/data area and not allocated
in stack, so this doesn’t lead to dangling pointers.
(29) char *someFun1()
{
char temp[ ] = “string";
return temp;
}
char *someFun2()
{
char temp[ ] = {‘s’, ‘t’,’r’,’i’,’n’,’g’};
return temp;
}
int main()
{
puts(someFun1());
puts(someFun2());
}
Answer:
Garbage
values.
Explanation:
Both
the functions suffer from the problem of dangling pointers. In someFun1() temp
is a character array and so the space for it is allocated in heap and is
initialized with character string “string”. This is created dynamically as the
function is called, so is also deleted dynamically on exiting the function so
the string data is not available in the calling function main() leading to
print some garbage values. The function someFun2() also suffers from the same
problem but the problem can be easily identified in this case.
ADO.NET has two type classes connected and disconnected.
