26. When should
the volatile modifier be used?
The volatile modifier is a directive to the
compiler’s optimizer that operations involving this variable should not be
optimized in certain ways. There are two special cases in which use of the
volatile modifier is desirable. The first case involves memory-mapped hardware
(a device such as a graphics adaptor that appears to the computer’s hardware as
if it were part of the computer’s memory), and the second involves shared
memory (memory used by two or more programs running simultaneously).
27. When should
the register modifier be used?
The register modifier hints to the compiler
that the variable will be heavily used and should be kept in the CPU’s
registers, if possible, so that it can be accessed faster.
28. How can you
determine the size of an allocated portion of memory?
You can’t, really. free() can , but there’s
no way for your program to know the trick free() uses. Even if you disassemble
the library and discover the trick, there’s no guarantee the trick won’t change
with the next release of the compiler.
29. When does the
compiler not implicitly generate the address of the first element of an
array?
Whenever an array name appears in an
expression such as
· array as an operand of the size of operator
· array as an operand of & operator
· array as a string literal initializer for a character array
Then the compiler does not implicitly generate the address of the address of
the first element of an array.
30. Why n++ executes
faster than n+1 ?
The expression n++ requires a single machine
instruction such as INR to carry out the increment operation whereas, n+1
requires more instructions to carry out this operation.
31. Why doesn't the
following statement work?
char str[ ] = "Hello" ;
strcat ( str, '!' ) ;
Answer: The string function strcat( )
concatenates strings and not a character. The basic difference between a string
and a character is that a string is a collection of characters, represented by
an array of characters whereas a character is a single character. To make the
above statement work writes the statement as shown below:
strcat ( str, "!" ) ;
32. What is the
benefit of using #define to declare a constant?
Using the #define method of declaring a
constant enables you to declare a constant in one place and use it throughout
your program. This helps make your programs more maintainable, because you need
to maintain only the #define statement and not several instances of individual
constants throughout your program.
For instance, if your program used the value
of pi (approximately 3.14159) several times, you might want to declare a
constant for pi as follows: #define PI 3.14159
Using the #define method of declaring a
constant is probably the most familiar way of declaring constants to
traditional C programmers. Besides being the most common method of declaring
constants, it also takes up the least memory.
Constants defined in this manner are simply
placed directly into your source code, with no variable space allocated in
memory. Unfortunately, this is one reason why most debuggers cannot inspect
constants created using the #define method.
33. What is the
purpose of main( ) function ?
The function main( ) invokes other functions
within it.It is the first function to be called when the program starts
execution.
· It is the starting function
· It returns an int value to the environment that called the program
· Recursive call is allowed for main( ) also.
· It is a user-defined function
· Program execution ends when the closing brace of the function main( ) is
reached.
· It has two arguments 1)argument count and 2) argument vector (represents
strings passed).
· Any user-defined name can also be used as parameters for main( ) instead of
argc and argv
34. How can I search
for data in a linked list?
Unfortunately, the only way to search a
linked list is with a linear search, because the only way a linked list’s
members can be accessed is sequentially.
Sometimes it is quicker to take the data from a linked list and store it in a
different data structure so that searches can be more efficient.
35. Why should we
assign NULL to the elements (pointer) after freeing them?
This is paranoia based on long experience.
After a pointer has been freed, you can no longer use the pointed-to data. The
pointer is said to dangle; it doesn’t point at anything useful.
If you NULL out or zero out a pointer
immediately after freeing it, your program can no longer get in trouble by
using that pointer. True, you might go indirect on the null pointer instead,
but that’s something your debugger might be able to help you with immediately.
Also, there still might be copies of the
pointer that refer to the memory that has been deallocated; that’s the nature
of C. Zeroing out pointers after freeing them won’t solve all problems.
36. What is a null
pointer assignment error? What are bus errors, memory faults, and core dumps?
These are all serious errors, symptoms of a
wild pointer or subscript. Null pointer assignment is a message you might
get when an MS-DOS program finishes executing. Some such programs can arrange
for a small amount of memory to be available “where the NULL pointer points to
(so to speak). If the program tries to write to that area, it will overwrite
the data put there by the compiler.
When the program is done, code generated by
the compiler examines that area. If that data has been changed, the
compiler-generated code complains with null pointer assignment. This message
carries only enough information to get you worried. There’s no way to tell,
just from a null pointer assignment message, what part of your program is
responsible for the error. Some debuggers, and some compilers, can give you
more help in finding the problem.
Bus error: core dumped and Memory fault: core
dumped are messages you might see from a program running under UNIX. They’re
more programmer friendly. Both mean that a pointer or an array subscript was
wildly out of bounds. You can get these messages on a read or on a write. They
aren’t restricted to null pointer problems. The core dumped part of the message
is telling you about a file, called core, that has just been written in your
current directory. This is a dump of everything on the stack and in the heap at
the time the program was running. With the help of a debugger, you can use the
core dump to find where the bad pointer was used. That might not tell you
why the pointer was bad, but it’s a step in the right direction. If you don’t
have write permission in the current directory, you won’t get a core file, or
the core dumped message
37. Predict the
output or error(s) for the following programmes:
void main()
{
int const * p=5;
printf("%d",++(*p));
}
Answer: Compiler error: Cannot modify a
constant value.
Explanation: p is a pointer to a "constant integer". But we tried to
change the value of the "constant integer".
38. main()
{
char s[ ]="man";
int i;
for(i=0;s[ i ];i++)
printf("\n%c%c%c%c",s[ i ],*(s+i),*(i+s),i[s]);
}
Answer:
mmm
aaaa
nnnn
Explanation: s[i], *(i+s), *(s+i), i[s] are
all different ways of expressing the same idea. Generally array name is the
base address for that array. Here s is the base address. i is the index
number/ displacement from the base address. So, indirecting it with * is same
as s[i]. i[s] may be surprising. But in the case of C it is same as s[i].
39. main()
{
float me = 1.1;
double you = 1.1;
if(me==you)
printf("I love U");
else
printf("I hate U");
}
Answer: I hate U
Explanation: For floating point numbers (float, double, long double) the
values cannot be predicted exactly. Depending on the number of bytes, the
precession with of the value represented varies. Float takes 4 bytes and long
double takes 10 bytes. So float stores 0.9 with less precision than long double.
Rule of Thumb: Never compare or at-least
be cautious when using floating point numbers with relational operators (== ,
>, <, <=, >=,!= ) .
40. main()
{
static int var = 5;
printf("%d ",var--);
if(var)
main();
}
Answer: 5 4 3 2 1
Explanation: When static storage class is given, it is initialized once. The
change in the value of a static variable is retained even between the function
calls. Main is also treated like any other ordinary function, which can be
called recursively.
41. main()
{
int c[ ]={2.8,3.4,4,6.7,5};
int j,*p=c,*q=c;
for(j=0;j<5;j++) {
printf(" %d ",*c);
++q; }
for(j=0;j<5;j++){
printf(" %d ",*p);
++p; }
}
Answer: 2 2 2 2 2 2 3 4 6 5
Explanation: Initially pointer c is assigned
to both p and q. In the first loop, since only q is incremented and not c , the
value 2 will be printed 5 times. In second loop p itself is incremented. So the
values 2 3 4 6 5 will be printed.
42. main()
{
extern int i;
i=20;
printf("%d",i);
}
Answer: Linker Error : Undefined symbol
'_i'
Explanation: extern storage class in the
following declaration,
extern int i;
specifies to the compiler that the memory for i is allocated in some other
program and that address will be given to the current program at the time of
linking. But linker finds that no other variable of name i is available in any
other program with memory space allocated for it. Hence a linker error has
occurred .
43. main()
{
int i=-1,j=-1,k=0,l=2,m;
m=i++&&j++&&k++||l++;
printf("%d %d %d %d %d",i,j,k,l,m);
}
Answer: 0 0 1 3 1
Explanation: Logical operations always give a
result of 1 or 0. And also the logical AND (&&) operator has higher
priority over the logical OR (||) operator. So the expression ‘i++ &&
j++ && k++’ is executed first. The result of this expression is 0 (-1
&& -1 && 0 = 0). Now the expression is 0 || 2 which evaluates
to 1 (because OR operator always gives 1 except for ‘0 || 0’ combination- for
which it gives 0). So the value of m is 1. The values of other variables are
also incremented by 1.
44. main()
{
char *p;
printf("%d %d ",sizeof(*p),sizeof(p));
}
Answer: 1 2
Explanation: The sizeof() operator gives the
number of bytes taken by its operand. P is a character pointer, which needs one
byte for storing its value (a character). Hence sizeof(*p) gives a value of 1.
Since it needs two bytes to store the address of the character pointer
sizeof(p) gives 2.
45. main()
{
int i=3;
switch(i)
{
default:printf("zero");
case 1: printf("one");
break;
case 2:printf("two");
break;
case 3: printf("three");
break;
}
}
Answer : Three
Explanation: The default case can be placed
anywhere inside the loop. It is executed only when all other cases doesn't
match.
46. main()
{
printf("%x",-1<<4);
}
Answer: fff0
Explanation: -1 is internally represented as
all 1's. When left shifted four times the least significant 4 bits are filled
with 0's.The %x format specifier specifies that the integer value be printed as
a hexadecimal value.
47. main()
{
char string[]="Hello World";
display(string);
}
void display(char *string)
{
printf("%s",string);
}
Answer: Compiler Error: Type mismatch in
redeclaration of function display
Explanation: In third line, when the function
display is encountered, the compiler doesn't know anything about the function
display. It assumes the arguments and return types to be integers, (which is
the default type). When it sees the actual function display, the arguments and
type contradicts with what it has assumed previously. Hence a compile time
error occurs.
48. main()
{
int c=- -2;
printf("c=%d",c);
}
Answer: c=2;
Explanation: Here unary minus (or negation)
operator is used twice. Same maths rules applies, ie. minus * minus= plus.
Note: However you cannot give like --2.
Because -- operator can only be applied to variables as a decrement operator
(eg., i--). 2 is a constant and not a variable.
49. #define int char
main()
{
int i=65;
printf("sizeof(i)=%d",sizeof(i));
}
Answer: sizeof(i)=1
Explanation: Since the #define replaces the
string int by the macro char
50. main()
{
int i=10;
i=!i>14;
Printf ("i=%d",i);
}
Answer: i=0
Explanation: In the expression !i>14 , NOT
(!) operator has more precedence than ‘ >’ symbol. ! is a unary logical
operator. !i (!10) is 0 (not of true is false). 0>14 is false (zero).
No comments:
Post a Comment