Explanation:

Step 1: char *str[] = {“Frogs”, “Do”, “Not”, “Die”, “They”, “Croak!”}; The variable str is declared as an pointer to the array of 6 strings.

Step 2: printf(“%d, %d”, sizeof(str), strlen(str[0]));

sizeof(str) denotes 6 * 4 bytes = 24 bytes. Hence it prints ’24’

strlen(str[0])); becomes strlen(Frogs)). Hence it prints ‘5’;

Hence the output of the program is 24, 5

Hint: If you run the above code in 16 bit platform (Turbo C under DOS) the output will be 12, 5. Because the pointer occupies only 2 bytes. If you run the above code in Linux (32 bit platform), the output will be 24, 5 (because the size of pointer is 4 bytes).

Explanation:

In scanf() a * in a format string after a % sign is used for the suppression of assignment. That is, the current input field is scanned but not stored.

Explanation:

printf(“%f\n”, sqrt(36.0)); It prints the square root of 36 in the float format(i.e 6.000000).

Declaration Syntax: double sqrt(double x) calculates and return the positive square root of the given number.

Explanation:

near=2, far=4 and huge=4 pointers exist only under DOS. Under windows and Linux every pointers is 4 bytes long.

Explanation:

Step 1: A macro named MAX is defined with value 128

Step 2: const int max=128; The constant variable max is declared as an integer data type and it is initialized with value 128.

Step 3: char array[max]; This statement reports an error “constant expression required”. Because, we cannot use variable to define the size of array.

To avoid this error, we have to declare the size of an array as static. Eg. char array[10]; or use macro char array[MAX];

Note: The above program will print A A as output in Unix platform.

Explanation:

False, Always the macro is substituted by the given text/expression.

Explanation:

for(i=1; i<=5; i++) Here the for loop runs 5 times.

Loop 1:
scanf(“%c”, &c); Here we give ‘a’ as input.
printf(“%c”, c); prints the character ‘a’ which is given in the previous “scanf()” statement.
ungetc(c, stdin); “ungetc()” function pushes character ‘a’ back into input stream.

Loop 2:
Here the scanf(“%c”, &c); get the input from “stdin” because of “ungetc” function.
printf(“%c”, c); Now variable c = ‘a’. So it prints the character ‘a’.
ungetc(c, stdin); “ungetc()” function pushes character ‘a’ back into input stream.

This above process will be repeated in Loop 3, Loop 4, Loop 5.

Explanation:

Syntax: void *malloc(size_t size);

The malloc() function shall allocate unused space for an object whose size in bytes is specified by size and whose value is unspecified.

The order and contiguity of storage allocated by successive calls to malloc() is unspecified. The pointer returned if the allocation succeeds shall be suitably aligned so that it may be assigned to a pointer to any type of object and then used to access such an object in the space allocated (until the space is explicitly freed or reallocated). Each such allocation shall yield a pointer to an object disjoint from any other object. The pointer returned points to the start (lowest byte address) of the allocated space. If the space cannot be allocated, a null pointer shall be  returned. If the size of the space requested is 0, the behavior is implementation-defined: the value returned shall be either a null pointer or a unique pointer.

Explanation:

fmod(x,y) – Calculates x modulo y, the remainder of x/y.
This function is the same as the modulus operator. But fmod() performs floating point or long double divisions

Explanation:

Declaration:

char *strnset(char *s, int ch, size_t n); Sets the first n characters of s to ch

#include <stdio.h>

#include <string.h>

int main(void)

{

char *string = “abcdefghijklmnopqrstuvwxyz”;

char letter = ‘x’;

printf(“string before strnset: %s\n”, string);

strnset(string, letter, 13);

printf(“string after  strnset: %s\n”, string);

return 0;

}

Output:

string before strnset: abcdefghijklmnopqrstuvwxyz

string after strnset: xxxxxxxxxxxxxnopqrstuvwxyz

Bit field type must be signed int or unsigned int.

The char type: char scheme:4; is also a valid statement.

Explanation:

No, In a function two return statements can occur but not successively.

Example:

#include <stdio.h>

int mul(int, int); /* Function prototype */

int main()

{

int a = 0, b = 3, c;

c = mul(a, b);

printf(“c = %d\n”, c);

return 0;

}

/* Two return statements in the mul() function */

int mul(int a, int b)

{

if(a == 0 || b == 0)

{

return 0;

}

else

{

return (a * b);

}

}

Output:
c = 0

Explanation:

The switch/case statement in the c language is defined by the language specification to use an int value, so you can not use a float value.

switch( expression )

{

case constant-expression1:    statements 1;

case constant-expression2:    statements 2;

case constant-expression3:    statements3 ;

…

…

default : statements 4;

}

The value of the ‘expression’ in a switch-case statement must be an integer, char, short, long. Float and double are not allowed.

Explanation:

Step 1: char str1[20] = “Hello”, str2[20] = ” World”; The variable str1 and str2 is declared as an array of characters and initialized with value “Hello” and ” World” respectively.

Step 2: printf(“%s\n”, strcpy(str2, strcat(str1, str2)));

=> strcat(str1, str2)) it append the string str2 to str1. The result will be stored in str1. Therefore str1 contains “Hello World”.

=> strcpy(str2, “Hello World”) it copies the “Hello World” to the variable str2.

Hence it prints “Hello World”.

Explanation:

The macro function SQUARE(x) x*x calculate the square of the given number ‘x’. (Eg: 10²)

Step 1: float s=10, u=30, t=2, a; Here the variable s, u, t, a are declared as an floating point type and the variable s, u, t are initialized to 10, 30, 2.

Step 2: a = 2*(s-u*t)/SQUARE(t); becomes,

=> a = 2 * (10 – 30 * 2) / t * t; Here SQUARE(t) is replaced by macro to t*t .

=> a = 2 * (10 – 30 * 2) / 2 * 2;

=> a = 2 * (10 – 60) / 2 * 2;

=> a = 2 * (-50) / 2 * 2 ;

=> a = 2 * (-25) * 2 ;

=> a = (-50) * 2 ;

=> a = -100;

Step 3: printf(“Result=%f”, a); It prints the value of variable ‘a’.

Hence the output of the program is -100

Explanation:

The correct way is char *q=0 (or) char *q=(char*)0

Explanation:

Yes you have to compile a program like
tcc myprog wildargs.obj

Explanation:

The basic C compiler is 16 bit compiler, below are the size of it’s data types
The size of short int is 2 bytes wide(16 bits).
The size of long int is 4 bytes wide(32 bits).

Explanation:

2. Arithmetic operators: *, /, %, +, –
1. Relational operators: >, <, >=, <=, ==, !=
3. Logical operators : !, &&, ||
4. Assignment operators: =

Explanation:

This program will result in error “Statement missing ;”

printf(“x is less than y\n”) here ; should be added to the end of this statement.

Explanation:

This type of declaration is called as self-referential structure. Here *e is pointer to a struct emp.

Explanation:

False, The scope of macros is globals and functions. Also the scope of macros is only from the point of definition to the end of the file.

Explanation:

No, both the statements are same. It is the prototype for the function fun() that accepts one integer array as an parameter and returns an integer value.

Explanation:

Step 1: int get(); This is the function prototype for the funtion get(), it tells the compiler returns an integer value and accept no parameters.

Step 2: const int x = get(); The constant variable x is declared as an integer data type and initialized with the value “20”.

The function get() returns the value “20”.

Step 3: printf(“%d”, x); It prints the value of the variable x.

Hence the output of the program is “20”.

Explanation:

Step 1: const c = -11; The constant variable ‘c’ is declared and initialized to value “-11”.

Step 2: const int d = 34; The constant variable ‘d’ is declared as an integer and initialized to value ’34’.

Step 3: printf(“%d, %d\n”, c, d); The value of the variable ‘c’ and ‘d’ are printed.

Explanation:

There are 2 errors in this program.
1. “Undefined symbol x” error. Here x is not defined in the program.
2. Here while() statement syntax error.

Explanation:

C uses left associativity for evaluating expressions to break a tie between two operators having same precedence

Explanation:

ceil(x) round up the given value. It finds the smallest integer not < x.
floor(x) round down the given value. It finds the smallest integer not > x.

printf(“%f, %f\n”, ceil(n), floor(n)); In this line ceil(1.54) round up the 1.54 to 2 and floor(1.54) round down the 1.54 to 1.

In the printf(“%f, %f\n”, ceil(n), floor(n)); statement, the format specifier “%f %f” tells output to be float value. Hence it prints 2.000000 and 1.000000.

Explanation:

The conditional macro #if must have an #endif. In this program there is no #endif statement written.

Explanation:

True, the programmer tells the compiler to include the preprocessor when compiling.

Explanation:

The following is the example program to explain “using bit fields inside an union”.

#include<stdio.h>

union Point

{

unsigned int x:4;

unsigned int y:4;

int res;

};

int main()

{

union  Point pt;

pt.x = 2;

pt.y = 3;

pt.res = pt.y;

printf(“\n The value of res = %d” , pt.res);

return 0;

}

// Output: The value of res = 3

Explanation:

1. The array int num[26]; can store 26 elements. This statement is true.
2. The expression num[1] designates the very first element in the array. This statement is false, because it designates the second element of the array.
3. It is necessary to initialize the array at the time of declaration. This statement is false.
4. The declaration num[SIZE] is allowed if SIZE is a macro. This statement is true, because the MACRO just replaces the symbol SIZE with given value.

Hence the statements ‘1’ and ‘4’ are correct statements.

Explanation:

The keyword return is used to transfer control from a function back to the calling function.

Example:

#include<stdio.h>

int add(int, int); /* Function prototype */

int main()

{

int a = 4, b = 3, c;

c = add(a, b);

printf(“c = %d\n”, c);

return 0;

}

int add(int a, int b)

{

/* returns the value and control back to main() function */

return (a+b);

}

Output:
c = 7

Explanation:

Step 1: char ch = ‘A’; The variable ch is declared as an character type and initialized with value ‘A’.

Step 2:

printf(“%d, %d, %d”, sizeof(ch), sizeof(‘A’), sizeof(3.14));

The sizeof function returns the size of the given expression.

sizeof(ch) becomes sizeof(char). The size of char is 1 byte.

sizeof(‘A’) becomes sizeof(65). The size of int is 4 bytes (as mentioned in the question).

sizeof(3.14f). The size of float is 4 bytes.

Hence the output of the program is 1, 4, 4

Explanation:

Step 1: int k, num=30; here variable k and num are declared as an integer type and variable num is initialized to ’30’.
Step 2: k = (num>5 ? (num <=10 ? 100 : 200): 500); This statement does not affect the output of the program. Because we are going to print the variable num in the next statement. So, we skip this statement.
Step 3: printf(“%d\n”, num); It prints the value of variable num ’30’
Step 3: Hence the output of the program is ’30’

Explanation:

Declaration: char *fgets(char *s, int n, FILE *stream);

fgets reads characters from stream into the string s. It stops when it reads either n – 1 characters or a newline character, whichever comes first.

Therefore, the string str contain “I am a boy\n\0”

Explanation:

The order of evaluation of arguments passed to a function call is unspecified.

Anyhow, we consider ++i, ++i are Right-to-Left associativity. The output of the program is 4, 3.

In TurboC, the output will be 4, 3.

In GCC, the output will be 4, 4.

Explanation:

The equal to = operator has Right-to-Left Associativity. So it assigns b=5 then a=b.

Explanation:

The while(j <= 255) loop will get executed 255 times. The size short int(2 byte wide) does not affect the while() loop.

Explanation:

Step 1:

printf(“%d, %d, %d”, sizeof(3.0f), sizeof(‘3’), sizeof(3.0));

The sizeof function returns the size of the given expression.

sizeof(3.0f) is a floating point constant. The size of float is 4 bytes

sizeof(‘3’) It converts ‘3’ in to ASCII value.. The size of int is 2 bytes

sizeof(3.0) is a double constant. The size of double is 8 bytes

Hence the output of the program is 4,2,8

Note: The above program may produce different output in other platform due to the platform dependency of C compiler.

In Turbo C, 4 2 8. But in GCC, the output will be 4 4 8.

Explanation:

The function printf() returns the number of charecters printed on the console.

Step 1: char a[] = “\0”; The variable a is declared as an array of characters and it initialized with “\0”. It denotes that the string is empty.

Step 2: if(printf(“%s”, a)) The printf() statement does not print anything, so it returns ‘0’(zero). Hence the if condition is failed.

In the else part it prints “The string is not empty”.

Explanation:

Use realloc(variable_name, value);

Explanation:

The scanf function returns the number of input is given.

printf(“%d\n”, scanf(“%d”, &i)); The scanf function returns the value 1(one).

Therefore, the output of the program is ‘1’.

Explanation:

math.h is a header file in the standard library of C programming language designed for basic mathematical operations.

Declaration syntax: double log(double);

Explanation:

Step 1: int i=-3, j=2, k=0, m; here variable i, j, k, m are declared as an integer type and variable i, j, k are initialized to -3, 2, 0 respectively.

Step 2: m = ++i && ++j || ++k;
becomes m = (-2 && 3) || ++k;
becomes m = TRUE || ++k;.
(++k) is not executed because (-2 && 3) alone return TRUE.
Hence this statement becomes TRUE. So it returns ‘1’(one). Hence m=1.

Step 3: printf(“%d, %d, %d, %d\n”, i, j, k, m); In the previous step the value of i,j are increemented by ‘1’(one).

Hence the output is “-2, 3, 0, 1”.

Explanation:

A compiler may leave holes in structures by padding the first char in the structure with another byte just to ensures that the integer that follows is stored at an location. Also, there might be 2extra bytes after the integer to ensure that the long integer is stored at an address, which is multiple of 4. Such alignment is done by machines to improve the efficiency of accessing values.