C Programming: 5-Chapter Comprehensive Practice & 75 Verified MCQs

Question 1

Which operator in C is used to dereference a pointer variable and access the value residing at the pointed memory address?

Accepted Answer

B. * (Indirection / Dereference operator). The asterisk (*) acts as the indirection (dereference) operator when applied to an existing pointer. It reads or writes the value located at the memory address stored in the pointer variable. In contrast, '&' retrieves the memory address of an lvalue.

Question 2

What will be the printed output of the following C code snippet?

int x = 5;
int y = ++x * 2;
printf("%d %d", x, y);

Accepted Answer

C. 6 12. The pre-increment operator '++x' increments the value of x from 5 to 6 before its value is evaluated in the multiplication expression. Consequently, y evaluates to 6 * 2 = 12, leaving x as 6 and y as 12.

Question 3

Which bitwise expression in C isolates and checks whether the 3rd bit (0-indexed from right) of an integer variable 'flags' is set to 1?

Accepted Answer

A. flags & (1 << 3). Shifting 1 to the left by 3 positions ('1 << 3') generates the binary mask '00001000' (decimal 8). Performing a bitwise AND ('flags &#038; 8') results in a non-zero value if the 3rd bit is set, and 0 if it is clear.

Question 4

How does the logical AND operator (&#038;&#038;) behave in C when the left-hand operand evaluates to false (0)?

Accepted Answer

B. The right-hand operand is skipped entirely due to short-circuit evaluation.. C guarantees short-circuit evaluation for logical operators. For 'A &#038;&#038; B', if 'A' is false (0), the entire logical expression cannot possibly be true; thus, 'B' is never evaluated, preventing potential side effects or null-pointer dereferences in the second clause.

Question 5

What is the return value and behavior of the sizeof operator in C when evaluated on an array vs a decayed pointer?

Accepted Answer

A. It returns 10 * sizeof(int) for arr, and the machine architecture pointer width (e.g., 4 or 8 bytes) for ptr.. 'sizeof(arr)' evaluates the total byte size of the allocated contiguous block (10 elements * 4 bytes = 40 bytes on typical 32/64-bit systems). However, when assigned to 'ptr', array decay occurs, and 'sizeof(ptr)' only measures the pointer memory size (8 bytes on 64-bit platforms).

Question 6

According to the C99 and C11 standards, what is the result of the modulo operation (-14 % 3)?

Accepted Answer

B. -2. C99/C11 defines that integer division truncates toward zero: (-14 / 3) = -4. Because C enforces (a / b) * b + (a % b) == a, we have (-4 * 3) + remainder = -14 => -12 + remainder = -14, yielding remainder = -2. The sign of (a % b) strictly matches the sign of the dividend (a).

Question 7

What will be printed by the following code that utilizes the comma operator?

int a = (1, 2, 3) + (4, 5);
printf("%d", a);

Accepted Answer

B. 8. The comma operator evaluates each sub-expression from left to right and yields the value of the rightmost sub-expression. Thus, '(1, 2, 3)' evaluates to 3, and '(4, 5)' evaluates to 5. Adding them together gives 3 + 5 = 8.

Question 8

What is the primary difference between the bitwise NOT operator (~) and the logical NOT operator (!) in C?

Accepted Answer

A. '~' operates on every bit (1s complement), while '!' converts non-zero to 0 and 0 to 1.. The bitwise NOT operator '~' inverts every individual bit of its operand (0 becomes 1 and 1 becomes 0, producing the one's complement). The logical NOT operator '!' performs a truth-table inversion: it returns 1 if the operand is 0, and 0 if the operand is any non-zero value.

Question 9

What does the expression 'ptr++' do when ptr is a pointer of type 'int *' on a 64-bit architecture where sizeof(int) is 4 bytes?

Accepted Answer

B. Increments the numerical memory address in ptr by 4 bytes (sizeof(int)).. Pointer arithmetic in C is scaled by the size of the referenced type. Incrementing 'ptr++' advances the address by 1 unit of 'int', which is 4 bytes. It points to the next sequential integer in contiguous memory.

Question 10

Which of the following operators cannot be used with floating-point operands (float, double) in C?

Accepted Answer

B. % (Modulo remainder operator). The '%' (modulo) operator requires both operands to be of integer types (such as char, int, long). Using '%' on floating-point numbers triggers a compile-time error. For floating-point remainder, the standard library function 'fmod()' from <math.h> must be used.

Question 11

In the expression 'int res = a > b ? a : b;', what is the operator category and arity of '?:'?

Accepted Answer

B. Ternary conditional operator. The '?:' operator is the only ternary operator in C because it requires exactly three operands: a condition, an expression evaluated if the condition is true (non-zero), and an expression evaluated if false (zero).

Question 12

What will be the output of the following C code snippet?

int x = 10, y = 20, z = 30;
int r = x < y < z;
printf("%d", r);

Accepted Answer

A. 1. Relational operators have left-to-right associativity. First, 'x < y' (10 < 20) evaluates to true (1). Next, the expression becomes '1 < z' (1 < 30), which also evaluates to true (1). Therefore, r is assigned 1.

Question 13

What is the order of evaluation between prefix increment and pointer dereference in the expression '*++ptr'?

Accepted Answer

B. ptr is incremented first, and then the newly pointed-to memory address is dereferenced.. Prefix increment '++' and dereference '*' share the same precedence level and associate from right to left. Because '++' is adjacent to 'ptr' on the right, '++ptr' evaluates first (advancing the pointer), and then '*' dereferences the updated address.

Question 14

Which bitwise operation clears (sets to 0) the least significant set bit (rightmost 1) of an unsigned integer 'n' in O(1) time?

Accepted Answer

A. n &#038; (n - 1). Subtracting 1 from n flips all bits starting from the rightmost set bit up to the least significant bit. When performing bitwise AND with the original n ('n &#038; (n - 1)'), the rightmost 1-bit becomes 0 while all higher-order bits remain unaffected. This is known as Brian Kernighan's bit algorithm.

Question 15

What will be printed when executing the following C code?

int a = 1;
if (a = 0)
    printf("True
");
else
    printf("False
");

Accepted Answer

B. False. The condition contains an assignment operator '=' rather than an equality operator '=='. The expression 'a = 0' assigns 0 to variable 'a' and evaluates to the assigned value, which is 0 (false in C). Therefore, the 'else' branch executes, printing 'False'.

Question 16

What is the return type of the malloc() function in C when memory is successfully allocated?

Accepted Answer

B. void *. malloc() returns a generic pointer of type 'void *' pointing to the beginning of the newly allocated contiguous byte block. Because void* implicitly converts to any data pointer type in C, explicit casting is not required.

Question 17

What happens if free(ptr) is called on a pointer variable that holds the value NULL?

Accepted Answer

B. No operation is performed and the function returns cleanly without error.. According to the ISO C standard (C99/C11 §7.22.3.4), if the argument passed to free() is a null pointer, no action is taken. It is completely safe and well-defined behavior.

Question 18

What is a 'Dangling Pointer' in C?

Accepted Answer

B. A pointer that points to a memory location that has already been deallocated or freed.. A dangling pointer arises when the memory block pointed to is released (via free() or stack frame pop) but the pointer variable still holds the deallocated address. Dereferencing a dangling pointer triggers undefined behavior.

Question 19

How does calloc(n, size) differ functionally from malloc(n * size)?

Accepted Answer

B. calloc zeroes out all allocated memory bytes to 0; malloc leaves memory uninitialized with indeterminate garbage values.. calloc() allocates memory for an array of n elements of specified size and explicitly initializes all bits in the allocated block to zero. malloc() merely locates an available block and leaves existing residual memory contents untouched.

Question 20

What will be printed when executing the following pointer arithmetic snippet on a 32-bit architecture where sizeof(int) is 4 bytes?

int arr[5] = {10, 20, 30, 40, 50};
int *p = arr;
printf("%d", *(p + 3));

Accepted Answer

C. 40. The expression 'p + 3' advances the pointer address by 3 * sizeof(int) bytes, targeting index 3 of the array. Dereferencing *(p + 3) yields arr[3], which is 40.

Question 21

What is the difference between 'const int *p' and 'int * const p' in C declarations?

Accepted Answer

A. 'const int *p' is a pointer to a constant integer (value cannot change); 'int * const p' is a constant pointer (address cannot change).. Read declarations from right to left: 'const int *p' means p is a pointer to an integer that is constant (*p cannot be modified). 'int * const p' means p is a const pointer to an integer (the address in p is locked and cannot point elsewhere, but *p can be modified).

Question 22

What does realloc(ptr, new_size) do if there is insufficient contiguous space at the current memory block to expand?

Accepted Answer

B. It allocates a brand new memory block of new_size elsewhere, copies the existing data payload to the new location, frees the old block, and returns the new pointer.. If in-place expansion is impossible, realloc() allocates a new chunk of heap memory of size 'new_size', copies the contents from the old buffer up to the minimum of the old and new sizes, releases the old buffer via free(), and returns a pointer to the new memory block.

Question 23

What is the result of subtracting two pointers pointing to elements in the same array: (ptr2 - ptr1)?

Accepted Answer

B. The number of elements between the two pointers (5 of type ptrdiff_t).. Pointer subtraction in C computes the number of elements of the referenced type between the two addresses: (Address2 - Address1) / sizeof(T). Here, 7 - 2 = 5 elements. The result has standard signed type 'ptrdiff_t' from <stddef.h>.

Question 24

What is a 'Memory Leak' in C?

Accepted Answer

B. Dynamically allocated heap memory that is no longer referenced by any pointer and was never deallocated using free(), leaving it unusable.. A memory leak occurs when a program allocates memory on the heap (via malloc, calloc, or realloc) but loses all pointers referencing that block without calling free(). Over time, repeated leaks consume available system RAM, causing performance degradation or crashes.

Question 25

What is the output of the following pointer dereferencing code?

int x = 100;
int *p = &x;
int **pp = &p;
printf("%d", **pp);

Accepted Answer

C. 100. 'p' holds the address of x. 'pp' is a pointer-to-a-pointer holding the address of p. The first dereference '*pp' resolves to 'p' (the address of x). The second dereference '**pp' resolves to the value of x itself, which is 100.

Question 26

What is a 'Wild Pointer' in C?

Accepted Answer

B. An uninitialized pointer variable that contains an arbitrary, unpredictable garbage memory address.. A wild pointer is a pointer variable declared without explicit initialization (e.g., 'int *p;'). It points to an arbitrary memory address determined by whatever random bits existed in that stack memory frame, making any dereference hazardous.

Question 27

Can you perform direct arithmetic (e.g. ptr++) on a pointer declared as 'void *' according to standard ANSI C?

Accepted Answer

B. No, standard C forbids arithmetic on void* because the size of an incomplete type (void) is undefined.. Because 'void' represents an incomplete type with no defined size, the ISO C standard strictly disallows pointer arithmetic on void*. (Note: GCC supports pointer arithmetic on void* as a non-standard compiler extension treating sizeof(void) as 1, but it is illegal in strict ISO C).

Question 28

What does the declaration 'int (*fp)(int, int);' declare in C?

Accepted Answer

B. A function pointer named 'fp' that points to a function taking two int arguments and returning an int.. The parentheses around '(*fp)' bind the asterisk to the identifier 'fp', establishing that fp is a pointer. The following '(int, int)' specifies the function parameter list, and the leading 'int' specifies the function's return type.

Question 29

What will occur if a program attempts to write data to a string literal through a pointer: 'char *str = "Hello"; str[0] = 'M';'?

Accepted Answer

B. Undefined behavior, typically resulting in a segmentation fault or bus error.. In C, string literals like "Hello" are placed in read-only data segments (.rodata). Attempting to modify read-only memory through a char* pointer causes a hardware write-protection fault (SIGSEGV).

Question 30

What is the purpose of the 'alloca()' function in environments where it is supported?

Accepted Answer

B. Allocates temporary memory on the runtime stack frame, which is automatically deallocated when the enclosing function returns.. 'alloca()' allocates memory on the stack rather than the heap. Memory allocated with alloca() is automatically released when the calling function exits (when the stack pointer is restored), eliminating the need for free().

Question 31

What is the lifetime and scope of a local variable declared with the 'static' storage class specifier inside a function?

Accepted Answer

B. Lifetime is the entire program execution; Scope is local strictly to the function.. A static local variable is initialized exactly once (before program startup) and retains its value between successive calls for the entire lifespan of the program. However, its visibility (scope) remains strictly restricted to the block or function where it is declared.

Question 32

What does declaring a global variable or function with the 'static' keyword at file scope achieve?

Accepted Answer

B. It restricts the linkage to internal linkage, making the symbol invisible to other translation units (object files) during the linking phase.. At file scope, 'static' gives a variable or function internal linkage. This encapsulates the symbol within its current source (.c) file, preventing name collisions with identical symbols in other translation units.

Question 33

What is the default storage class of local variables declared inside a C function if no storage specifier is provided?

Accepted Answer

C. auto. Local variables declared inside a block or function have the 'auto' (automatic) storage class by default. Their storage is allocated on the call stack upon block entry and deallocated upon block exit.

Question 34

What purpose does the 'extern' storage class specifier serve in a C program?

Accepted Answer

B. It declares a variable or function without defining it, notifying the compiler that its definition and storage reside in another translation unit or elsewhere.. 'extern' creates a declaration rather than a definition. It tells the compiler that the variable exists and has external linkage, instructing the linker to resolve its memory address across linked compilation modules.

Question 35

What will occur if a recursive function in C lacks a proper base case or terminates too deeply?

Accepted Answer

B. Stack overflow due to exhaustion of allocated call stack memory frames.. Every recursive call allocates a stack frame storing arguments, return addresses, and local variables. Without a terminating base case, recursion proceeds until the stack exceeds its OS boundary limit, triggering a stack overflow (SIGSEGV).

Question 36

What is 'Tail Recursion', and why is it significant for optimizing compilers?

Accepted Answer

B. When the recursive call is the final operation executed in the function, allowing compilers to reuse the current stack frame (Tail Call Optimization) avoiding stack growth.. In tail recursion, the function returns the direct result of the recursive call with no pending operations (like addition or multiplication) waiting. Optimizing compilers can replace the stack-frame push with a simple jump instruction, reducing O(N) stack space to O(1).

Question 37

What does the 'inline' function specifier suggest to the C compiler (introduced in C99)?

Accepted Answer

B. Hints to the compiler to substitute the function body directly at each call site, eliminating function call overhead (stack pushing/popping).. The 'inline' keyword suggests that the compiler replace calls to the function with the actual machine code instructions of the function body. This eliminates call overhead (parameter pushing, branch prediction stalls, stack frame creation) at the expense of potential code size expansion.

Question 38

How are function arguments passed by default in C?

Accepted Answer

A. Strictly Pass-by-Value. In C, ALL function arguments are passed strictly by value. A local copy of each argument is passed into the function parameters. To achieve pass-by-reference semantics, one passes a pointer value; the pointer itself is still passed by value, but dereferencing it accesses original caller memory.

Question 39

What is the consequence of declaring a variable with the 'register' storage class in C?

Accepted Answer

B. It hints to the compiler to store the variable in a CPU register for fast access, and forbids taking the address of that variable using the '&' operator.. 'register' requests that the compiler keep the variable in a machine register rather than RAM. Because registers do not have memory addresses, attempting to use the address-of operator '&i' on a register variable is an illegal compile-time error in C.

Question 40

What will be printed when executing the following recursive function with input n = 4?

void print_nums(int n) {
    if (n == 0) return;
    print_nums(n - 1);
    printf("%d ", n);
}

Accepted Answer

B. 1 2 3 4. Because the recursive call 'print_nums(n - 1)' occurs BEFORE the printf statement, calls cascade down until n == 0. When the call stack unwinds in LIFO order, the print statements execute in reverse order of invocation: 1, 2, 3, 4.

Question 41

Which header file and macros must be used to create functions accepting variable numbers of arguments (variadic functions) in C?

Accepted Answer

A. (va_list, va_start, va_arg, va_end). Variadic functions in C require '', which defines the 'va_list' type and the macros 'va_start' (to initialize the argument pointer), 'va_arg' (to fetch each argument by type), and 'va_end' (to clean up the stack state).

Question 42

What is the return value of a function in C if the return statement is omitted in a non-void function (other than main)?

Accepted Answer

B. Undefined behavior if the caller uses the return value.. If the '}' that terminates a non-void function is reached and the caller attempts to use the value of the function call, the behavior is strictly undefined. The caller will read whatever residual data resides in the machine return register (e.g., EAX/RAX).

Question 43

What is the difference between a function declaration (prototype) and a function definition in C?

Accepted Answer

A. A declaration specifies the function's name and signature without a body; a definition provides the actual executable implementation body.. A function declaration (prototype) informs the compiler of the function's name, return type, and parameter types (e.g. 'int add(int, int);'), allowing calls to be validated before definition. The function definition supplies the actual code block enclosed in braces.

Question 44

What does the 'noreturn' function specifier (or '_Noreturn' in C11) signify?

Accepted Answer

B. The function will never return control to the caller (e.g., calls exit() or enters an infinite loop), enabling dead-code elimination optimizations.. '_Noreturn' informs the compiler that the function will never return to its call site (e.g. abort(), exit()). This allows the compiler to suppress unused variable warnings and optimize stack cleanup.

Question 45

In C, what is the maximum number of values a function can return directly via the return statement?

Accepted Answer

B. Exactly one value (though it can be a struct containing multiple fields).. The C return statement returns at most one single value. However, that value can be a composite structure ('struct') containing multiple sub-variables, or multiple values can be returned via pointer arguments.

Question 46

What happens if a 'break' statement is omitted at the end of a 'case' block in a C switch statement?

Accepted Answer

B. Fall-through occurs: execution continues sequentially into the subsequent case block regardless of whether its condition matches.. Without a 'break' statement, C switch statements exhibit 'fall-through' behavior. Execution simply proceeds into the instructions of the next case label, ignoring its comparison condition until hitting a break or the end of the switch block.

Question 47

What data types are legally permitted as the expression inside a switch() statement in C?

Accepted Answer

B. Strictly integral types (int, char, short, long, enum).. The controlling expression of a switch statement in C must evaluate to an integer type (including signed/unsigned char, short, int, long, and enumerations). Floating-point values (float/double), strings, and structs are strictly forbidden.

Question 48

What is the primary difference between a 'while' loop and a 'do-while' loop in C?

Accepted Answer

B. 'while' is an entry-controlled loop (condition checked before loop body); 'do-while' is an exit-controlled loop (loop body executes at least once before condition check).. In a 'while' loop, the condition is evaluated prior to the first iteration, meaning the body may execute 0 times if initially false. A 'do-while' loop evaluates the condition at the end of the block, guaranteeing that the body executes at least once.

Question 49

What is the behavior of the 'continue' statement when executed inside a C 'for' loop?

Accepted Answer

B. It skips the remaining statements in the current iteration and jumps directly to the loop iteration expression ('i++'), then evaluates the condition.. In a 'for' loop, executing 'continue' skips remaining body statements and immediately executes the iteration/update step (i++). It then evaluates the conditional test. (In a while loop, continue jumps directly to the condition test).

Question 50

What will be printed when executing the following nested loop?

int count = 0;
for (int i = 0; i < 3; i++)
    for (int j = 0; j < 4; j++)
        count++;
printf("%d", count);

Accepted Answer

B. 12. The outer loop runs 3 times (i = 0, 1, 2). For each iteration of the outer loop, the inner loop executes 4 times (j = 0, 1, 2, 3). Total iterations = 3 * 4 = 12.

Question 51

What is the scope restriction of the 'goto' statement in C?

Accepted Answer

B. A goto statement can only jump to a labeled statement within the exact same function.. In C, labels have function scope. A 'goto' statement can only transfer control to a label located within the same function body. It cannot jump across function boundaries.

Question 52

What will occur if the condition expression is completely omitted in a for loop: 'for ( ; ; ) { ... }'?

Accepted Answer

C. An infinite loop: an omitted condition in a for loop evaluates to true (1) by standard definition.. According to the C standard (§6.8.5.3), if clause-2 (the controlling condition) of a for loop is omitted, it is treated as if replaced by a non-zero constant (true). Thus, 'for (;;)' creates an intentional infinite loop.

Question 53

What is the output of the following code snippet?

int x = 0;
if (x++)
    printf("A ");
else
    printf("B ");
printf("%d", x);

Accepted Answer

B. B 1. The post-increment 'x++' evaluates to the current value of x (0, which is false in C) for the if condition. After evaluation, x is incremented to 1. The 'else' branch executes, printing 'B ', followed by the final value of x, which is 1.

Question 54

Can a 'default' case be placed at the top or middle of a switch statement in C rather than at the bottom?

Accepted Answer

B. Yes, the position of the 'default' label inside a switch is arbitrary; it is only evaluated if no matching 'case' label matches.. In C, the 'default' label can appear anywhere within the switch block (beginning, middle, or end). Regardless of its placement, the switch engine checks all explicit case matches first; default only triggers if no matching case is found.

Question 55

What will be printed when executing this loop?

int i = 5;
while (i --> 0) {
    printf("%d ", i);
}

Accepted Answer

B. 4 3 2 1 0. '-->' is not a single operator; it is parsed by the C lexer as '(i--) > 0'. When i = 5, (5 > 0) is true, i decrements to 4, printing 4. When i = 1, (1 > 0) is true, i decrements to 0, printing 0. When i = 0, (0 > 0) is false, i decrements to -1, and loop exits. Printed: 4 3 2 1 0.

Question 56

What is the primary danger of using floating-point loop control variables, such as 'for (float f = 0.0f; f != 1.0f; f += 0.1f)'?

Accepted Answer

B. Rounding errors in binary floating point representation mean f may never equal 1.0f exactly, creating an infinite loop.. Because 0.1 cannot be represented precisely in IEEE 754 binary floating-point, accumulating 0.1 repeatedly introduces fractional rounding errors. Consequently, 'f' might reach 0.99999994 and then 1.0000001, never matching '!= 1.0f' exactly.

Question 57

What is the effect of an empty statement ';' inside a while loop header: 'while (condition);'?

Accepted Answer

B. The semicolon acts as a null statement representing the entire loop body; if 'condition' is true, the loop spins infinitely without executing the following braced block.. The trailing semicolon after 'while (i < 5);' constitutes the complete body of the loop. Because 'i' is never incremented inside that null body, (0 < 5) remains true forever, trapping the program in an infinite busy-wait.

Question 58

In a switch statement, can two different 'case' labels share the exact same constant value?

Accepted Answer

B. No, duplicate case values within the same switch block produce a compile-time error.. The C standard specifies that no two case constant expressions in the same switch statement may evaluate to the identical value. The compiler reports an error: 'duplicate case value'.

Question 59

What is the purpose of 'Duff’s Device' in C programming?

Accepted Answer

B. An unrolled loop optimization idiom that interleaves a switch statement with a do-while loop to copy serial chunks with minimal branch penalty.. Invented by Tom Duff, Duff's Device exploits C's switch fall-through to interleave a switch statement within a do-while loop. It achieves manual loop unrolling, handling arbitrary length buffers with minimal branch checks.

Question 60

What does a 'break' statement do when executed inside a nested loop in C?

Accepted Answer

B. Breaks out of ONLY the innermost enclosing loop or switch block.. The 'break' statement terminates execution of only the immediately enclosing switch, while, do, or for statement. It does not break out of outer enclosing loops.

Question 61

What character implicitly terminates all valid C string literals in memory?

Accepted Answer

B. '\0' (Null terminator / byte 0x00). C strings are zero-terminated arrays of characters. The null character '\0' (ASCII 0) marks the end of the character sequence in memory, allowing functions like strlen(), strcpy(), and printf("%s") to detect string bounds.

Question 62

What is 'Structure Padding' and alignment in C?

Accepted Answer

B. Unused filler bytes inserted by the compiler between struct members to align data types to CPU word boundary multiples for optimal memory bus performance.. CPUs access memory most efficiently when data types reside at memory addresses divisible by their size (e.g. 4-byte integers on 4-byte boundaries). Compilers automatically insert padding bytes between members (e.g., 3 padding bytes after 'char a' before 'int b'), making sizeof(struct Example) = 8 bytes instead of 5.

Question 63

How does a 'union' differ from a 'struct' in C?

Accepted Answer

B. All union members share the exact same memory location, and the size of the union equals the size of its largest member; a struct allocates separate memory for each member.. In a union, all member fields overlap in the exact same memory address. Writing to one member overwrites the others. A union's total memory allocation is determined strictly by the size of its largest member (plus alignment requirements).

Question 64

Why is the standard library function 'gets()' considered hazardous and formally removed from the C11 standard?

Accepted Answer

B. It has no mechanism to limit the number of characters read, creating fatal buffer overflow vulnerabilities if input exceeds buffer capacity.. 'gets()' reads lines from stdin until a newline is reached without accepting a buffer size limit parameter. If user input exceeds the target array size, adjacent stack memory is overwritten, causing crashes or arbitrary code execution exploits. C11 removed gets() entirely.

C Programming: 5-Chapter Comprehensive Practice & 75 Verified MCQs

C Programming: 5-Chapter Comprehensive Practice & 75 Verified MCQs

Explore Other Comprehensive 75-Question Subject Tracks

Queryiest

Queryiest – Technology Writer | Software Developer | Digital Learning Enthusiast

What is a database?

How to rotate an array in-place with O(1) space and ...

What steps can businesses take to identify the most valuable ...

Queryiest

Anonymous

paperubofficial