C Programming Fundamentals

ptr starts at index 0 pointing to 'a'. After ptr += 5, it points to index 5, which is 'f'. The string from that position is 'fg' (characters at indices 5 and 6). This is basic pointer arithmetic where the pointer moves forward by the specified number of elements.

The loop continues while (x-1) is non-zero. x starts at 3: (3-1)=2 true → counter=1, x=2. Next: (2-1)=1 true → counter=2, x=1. Next: (1-1)=0 false → exit. Final counter=2. This is correct.

The array is declared as char ** array[12][12][12], which is a 3D array of pointers to char . To point to this array, we need a pointer to the first element, which is char ** ()[12][12]. This matches option A. Options B and C have incorrect indirection levels. D adds const incorrectly. E has wrong pointer type.

ceil(-3.5) rounds UP to -3 (less negative), ceil(3.5) rounds up to 4. floor(-3.5) rounds DOWN to -4 (more negative), floor(3.5) rounds down to 3. The printf statements output: -3 : 4 (from ceils) then -4 : 3 (from floors).

x starts at 5. Since op='*' doesn't match any case, switch goes to default: x becomes 6. Without break, execution falls through to case '+': x += 2 makes x=8, then case '-': x -= 2 makes x=6. Fallthrough continues through all cases after the matching one.

asctime() converts a struct tm pointer (broken-down time) to a 26-character string like 'Wed Jun 30 21:49:08 1993\n'. ctime() converts time_t directly to string. localtime() and gmtime() convert time_t to struct tm, not string. Option D is correct.

testarray[4][3] has 12 elements total (4 rows × 3 columns). Each short is 2 bytes, so sizeof returns 12 × 2 = 24 bytes. The initializer fills only some elements, but sizeof still counts the full array declaration.

realloc resizes memory. To expand ptr to 10 elements: ptr = realloc(ptr, 10 * sizeof(struct customer)). Must assign result back to ptr (realloc may move memory). Option D uses 9 elements instead of 10. Options B and E don't assign return value. Option C is syntactically wrong.

A: False - void* pointers don't allow arithmetic. B: False - void* must be cast to dereference. C: False - C standard doesn't mandate minimum indirection levels. D: False - C has no runtime type checking. E: True - passing pointers lets functions modify original data, simulating call-by-reference.

The declaration means: signal is a function returning 'pointer to function taking int returning void'. To simplify, we typedef the return type: typedef void (*sighandler_t)(int). Then: sighandler_t signal(int sig, sighandler_t handler). This matches option A exactly.

Correct Answer: &&

clearerr() resets both the EOF and error indicators on a stream, allowing further I/O operations. fseek() only clears EOF on some implementations, not errors. feof() and ferror() only test conditions. setvbuf() controls buffering. Only clearerr() explicitly resets error/EOF states.

getchar() reads one character from stdin and returns it as an int (or EOF). Correct usage: c = getchar(). Option A uses getc() without stream argument. Options B and D pass address to getchar (wrong - it takes no arguments). Option C passes stdin to getchar (wrong signature). Only option E is correct.

%e displays floating-point in exponential notation (1.234e+05). %f displays in fixed-point decimal notation (123400.000000). Both take double arguments. Option A correctly describes this distinction. Option C is wrong - %e always uses exponential form, not conditionally.

The assignment operator (=) is right-associative, meaning it groups from right to left. For example, a = b = c is evaluated as a = (b = c), where c is assigned to b first, then the result is assigned to a. The comma operator (,), subscript ([]), bitwise XOR (^), and arrow operator (->) are all left-associative.

Initially, ptr2 points to dynamically allocated memory from malloc(5). The next statement reassigns ptr2 to point to ptr1, causing the reference to the original heap allocation to be lost without being freed, resulting in a classic memory leak.

The auto specifier in C indicates that a variable's memory storage duration is automatic - it's allocated when the block is entered and automatically deallocated when the block exits. This is the default storage class for local variables.

The global variable 'i' is used in the for-loop condition and print statement. However, the increment function takes 'int i' as a parameter, which shadows the global variable. The function increments its local parameter, not the global 'i'. Therefore, the global 'i' remains 0 forever, and the loop condition i < 10 is always true, causing an infinite loop.

System header files (those that come with the C compiler) are included using angle brackets: #include <filename.h>. This tells the preprocessor to look for the file in standard system directories. Double quotes (#include "filename.h") are used for user-defined header files, where the preprocessor first looks in the current directory.

The format specifier %-30.4f means: % begins the format, - left-aligns the output, 30 sets minimum field width, .4 specifies 4 decimal places, and f indicates decimal (not exponential) notation. This is the correct combination for a double value, left-aligned in a 30-character field with 4 digits of precision. The 'e' specifier would give exponential notation, and the order of width and precision matters.