Scholarship Test For 3 Month Online Project Development Program (Sep'10-nov'10)

* is a dereference operator & is a reference operator. They can be applied any number of times provided it is meaningful. Here p points to the first character in the string "Hello". *p dereferences it and so its value is H. Again & references it to an address and * dereferences it to the value H.

The given code snippet defines three functions: aaa, bbb, and ccc. These functions each print a different greeting message. In the main function, an array of function pointers called ptr is declared. The elements of this array are then assigned the addresses of the aaa, bbb, and ccc functions. Finally, the function pointed to by ptr[2] is called, which is ccc. Therefore, the output of the program would be "bye".

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.

Printf will return how many characters does it print. Hence printing a null character returns 1 which makes the if statement true, thus "Ok here" is printed.

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].

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 (== , >, =,!= ) .

\n - newline
\b - backspace
\r - linefeed

Explanation:
The case statement can have only constant expressions (this implies that we cannot use
variable names directly so an error).
Note:
Enumerated types can be used in case statements.

The code snippet is a C program that starts with initializing an integer variable i to 0. It then enters a for loop with an empty initialization statement, a condition of i++, and an empty increment statement. This means that i will be incremented after each iteration of the loop. Inside the loop, the printf function is used to print the value of i. However, since the condition i++ is always evaluated as true, the loop becomes an infinite loop. Therefore, the program will continuously print the incremented value of i, starting from 1. Hence, the correct answer is 1.

Runtime error-Stack overflow.main function calls itself again and again. Each time the function is called its return address is stored in the call stack. Since there is no condition to terminate the function call, the call stack overflows at runtime. So it terminates the program and results in an error.

The code snippet defines FALSE as -1, TRUE as 1, and NULL as 0. In the main function, the if statement checks if NULL is true. Since NULL is defined as 0, which is considered false, the if statement evaluates to false. The else if statement then checks if FALSE is true. Since FALSE is defined as -1, which is considered true, the else if statement evaluates to true. Therefore, the code will print "TRUE" as the output.

The given code declares an integer array 'a' of size 10. In the printf statement, the expression *a+1-*a+3 is evaluated. Since 'a' is an array, *a refers to the value at the first index of the array, which is the same as a[0]. So, *a+1 is equivalent to a[0]+1. Similarly, *a+3 is equivalent to a[0]+3. Therefore, the expression simplifies to a[0]+1-a[0]+3, which further simplifies to 1+3, resulting in the value 4 being printed.

Compier Error: '&' on register variable
Rule to Remember:
& (address of ) operator cannot be applied on register variables.

The code snippet initializes a variable 'not' as a character. The expression '!2' evaluates to 0, as the logical NOT operator (!) negates the truth value of the operand. The 'printf' function then prints the value of 'not', which is 0. Therefore, the correct answer is 0.

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).

The given code will result in a compilation error. This is because the code is missing the required header file, which is "stdio.h" for the printf() function.