C Programming Practice Exam — LearnCoachAssist

← Quit

C Programming Practice Exam

Question 1 of 50

60:00

Question 1 C Programming

What is signal() used for?

signal(sig, handler) installs handler as the function called when the process receives signal sig.
Common signals: SIGINT (Ctrl-C), SIGTERM, SIGSEGV, SIGFPE, SIGALRM.
Inside a signal handler, only async-signal-safe functions may be called; printf is generally not safe. static has two uses:

Inside a function: the variable retains its value between calls (persistent local)
At file scope: limits the variable or function's visibility to the current file (internal linkage)

<stdint.h> provides int8_t, int16_t, int32_t, int64_t and unsigned variants.
<inttypes.h> adds portable printf/scanf format macros like PRId32, SCNu64.
Use them when the exact bit-width matters, e.g. binary file formats or network protocols. Endianness is the order in which bytes of a multibyte value are stored in memory.

Little-endian: least significant byte first (x86, x86-64, ARM in most modes)
Big-endian: most significant byte first (network byte order, some older CPUs)

Use htons/ntohs for portable network code.

Question 24 C Programming

What is the associativity of assignment operators?

A static library (.a on Unix, .lib on Windows) is a bundle of object files linked into the executable at build time.
Created with ar rcs libfoo.a foo.o bar.o and used with -lfoo.
The result is a self-contained executable, but library updates require relinking. argc is the count of command-line arguments, including the program name.
argv[0] is the program name; argv[1] ... argv[argc-1] are the user arguments.
By convention, argv[argc] is a NULL pointer so iteration can stop without checking argc. size_t is the unsigned type used for sizes and counts — result of sizeof, arguments to malloc/strlen/memcpy, etc.
It is at least 16 bits and never smaller than int.
Loop counters or array indices that come from size_t should be compared with care, since they cannot be negative. Assignment operators (

=) are right-associative.
a = b = c = 5; is parsed as a = (b = (c = 5));, so c becomes 5, then b, then a.


                                
                    
                        Question 25
                        C Programming
                    
                    How does recursion work in C?
                    
                                                
                            
                            argc is the count of command-line arguments, including the program name.
argv[0] is the program name; argv[1] ... argv[argc-1] are the user arguments.
By convention, argv[argc] is a NULL pointer so iteration can stop without checking argc.
                        
                                                
                            
                            A function is recursive when it calls itself.
Each call creates a new stack frame with its own parameters and locals.
Every recursive function must have a base case that terminates recursion, otherwise the stack eventually overflows.
                        
                                                
                            
                            An enum (enumeration) defines a set of named integer constants.
enum Color { RED, GREEN, BLUE };
By default, values start at 0 and increment by 1.
You can assign custom values: enum Color { RED = 1, GREEN = 5 };
                        
                                                
                            
                            assert(expr) from <assert.h> checks expr; if it is false, it prints the file/line and calls abort().
Defining NDEBUG before including <assert.h> disables all asserts — they compile to nothing.
Use asserts for internal invariants, not for validating external input.
                        
                                            
                
                                
                    
                        Question 26
                        C Programming
                    
                    What is the difference between ++i and i++?
                    
                                                
                            
                            Prefix ++i increments i first, then returns the new value.
Postfix i++ returns the original value, then increments i.
In simple statements the result is the same final value of i, but in expressions the order matters, e.g. arr[i++] = x vs arr[++i] = x.
                        
                                                
                            
                            fclose(fp) closes an open file and flushes any buffered data to disk.
Failing to close files can cause:Data loss from unflushed buffers
Resource leaks (file descriptors are limited)
                        
                                                
                            
                            volatile tells the compiler that a variable's value may change unexpectedly (e.g., by hardware or another thread).
volatile int sensor_val;
Prevents the compiler from optimizing away reads of the variable, ensuring it is always fetched from memory.
                        
                                                
                            
                            strtod(str, &endptr) converts a string to a double.
It correctly handles whitespace, optional sign, decimal point, exponent, NaN, and infinity.
Like strtol, it sets endptr on failure; check it and errno for ERANGE.
                        
                                            
                
                                
                    
                        Question 27
                        C Programming
                    
                    What is the difference between strcmp() and strncmp()?
                    
                                                
                            
                            strcmp(a, b) compares whole strings; returns 0 if equal
strncmp(a, b, n) compares at most n characters; useful for prefixes (strncmp(s, "http://", 7))
Both use unsigned char comparisons.
                        
                                                
                            
                            A static library (.a on Unix, .lib on Windows) is a bundle of object files linked into the executable at build time.
Created with ar rcs libfoo.a foo.o bar.o and used with -lfoo.
The result is a self-contained executable, but library updates require relinking.
                        
                                                
                            
                            A sequence point is a point where all side effects of prior evaluations are complete and no side effects of future evaluations have occurred.
a = i++ + i++; has undefined behavior in C because i is modified and read between sequence points without sequencing.
Function calls, end of full expressions (;), and &&/||/,/?: introduce sequence points.
                        
                                                
                            
                            Definition: int counter = 0; — creates the object and allocates storage.
Declaration: extern int counter; — asserts that the variable exists elsewhere.
At file scope you may have many declarations but exactly one definition; otherwise the linker reports multiple-definition errors.
                        
                                            
                
                                
                    
                        Question 28
                        C Programming
                    
                    What is the relationship between #if, #elif, and #else?
                    
                                                
                            
                            #if evaluates a preprocessor expression (only integer literals, defined macros, and operators ==, !=, <, >, &&, ||, etc.):
#if defined(_WIN32)
// Windows code
#elif defined(__linux__)
// Linux code
#else
// fallback
#endif
#elif chains branches; #else is the catch-all.
                        
                                                
                            
                            strtol(str, &endptr, base) converts str to a long.
base may be 0 (auto-detect from 0x/0 prefix) or any value 2..36.
endptr points to the first character that was not part of the number; check it and errno for robust parsing.
                        
                                                
                            
                            Prefix ++i increments i first, then returns the new value.
Postfix i++ returns the original value, then increments i.
In simple statements the result is the same final value of i, but in expressions the order matters, e.g. arr[i++] = x vs arr[++i] = x.
                        
                                                
                            
                            A function prototype declares a function's return type, name, and parameter types without providing its body:
int add(int a, int b);
It lets the compiler check call-site argument types and allows functions to be used before their definition.
                        
                                            
                
                                
                    
                        Question 29
                        C Programming
                    
                    What is the register keyword?
                    
                                                
                            
                            Functions may be called with arguments whose types differ from the parameters; C performs default argument promotions.
In particular, float is promoted to double, and any integer smaller than int is promoted to int or unsigned int.
This is why C's variadic functions (via <stdarg.h>) use va_arg(ap, double) for floats.
                        
                                                
                            
                            _Noreturn (or the C11 attribute [[noreturn]]) marks a function that does not return to the caller.
_Noreturn void fatal(const char *msg);
Examples: exit(), abort(), longjmp()-terminated paths.
The compiler can then warn if code after the call is unreachable.
                        
                                                
                            
                            register suggests storing a local variable in a CPU register for faster access.
register int i;
Modern compilers ignore the hint; you also cannot apply the address-of operator & to a register variable.
                        
                                                
                            
                            setjmp(env) saves the current execution state (including registers, stack pointer) into env and returns 0.
longjmp(env, val) later restores that state, making setjmp return val (non-zero).
This is C's non-local goto: it can jump out of deeply nested calls but skips destructors/cleanup, so it interacts poorly with RAII-like idioms.
                        
                                            
                
                                
                    
                        Question 30
                        C Programming
                    
                    What is the difference between recursion and iteration?
                    
                                                
                            
                            A static initializer sets the initial value of a global or static variable at load time.
int counter = 42;
It must be a constant expression in C; non-constant initializers (e.g. function calls) became possible only as designated dynamic initializers in a recent proposal, otherwise the variable is zero-initialized before main.
                        
                                                
                            
                            memset(buf, value, n) sets the first n bytes of buf to value (interpreted as unsigned char).
memset(arr, 0, sizeof(arr)); zeroes an array.
It is the standard idiom for zeroing a struct or buffer.
                        
                                                
                            
                            Recursion uses repeated function calls; each call adds a stack frame, so memory grows with depth.
Iteration uses loops; memory usage is constant.
Any recursion can be rewritten as iteration, but recursive code can be clearer for tree/graph traversal.
                        
                                                
                            
                            abort() terminates the program abnormally.
It raises SIGABRT, which by default terminates the process without flushing buffers or running atexit handlers.
Used by assert() on failure; produces a core dump when enabled.
                        
                                            
                
                                
                    
                        Question 31
                        C Programming
                    
                    What is the difference between declaration and definition for variables?
                    
                                                
                            
                            strtol(str, &endptr, base) converts str to a long.
base may be 0 (auto-detect from 0x/0 prefix) or any value 2..36.
endptr points to the first character that was not part of the number; check it and errno for robust parsing.
                        
                                                
                            
                            Unspecified behavior: two or more outcomes are allowed; the compiler does not have to document which one
Implementation-defined behavior: the compiler must choose and document one behavior
Both are well-formed programs; only undefined behavior lets the compiler do anything at all.
                        
                                                
                            
                            Pointer arithmetic adjusts a pointer by multiples of the pointed-to type's size:
int *p = arr; p++; advances p by sizeof(int) bytes.
p + n points to the element n positions ahead.
Subtraction of two pointers gives the number of elements between them.
                        
                                                
                            
                            Definition: int counter = 0; — creates the object and allocates storage.
Declaration: extern int counter; — asserts that the variable exists elsewhere.
At file scope you may have many declarations but exactly one definition; otherwise the linker reports multiple-definition errors.
                        
                                            
                
                                
                    
                        Question 32
                        C Programming
                    
                    What is typedef used for in C?
                    
                                                
                            
                            They are equivalent in function parameters: both declare a pointer-to-pointer-to-char.
The array notation char *argv[] documents intent more clearly; char **argv is more abstract.
Inside main, you can index argv[i] like an array or use pointer arithmetic.
                        
                                                
                            
                            typedef creates an alias for an existing type, improving readability:
typedef unsigned long ulong;
typedef struct { int x; int y; } Point;
After this, you can write Point p; instead of struct Point p;
                        
                                                
                            
                            A memory leak occurs when dynamically allocated memory is never freed.
Example:
int *p = malloc(100);
p = malloc(200); // first block is leaked!
Over time, leaked memory accumulates and can exhaust available memory. Use tools like Valgrind to detect leaks.
                        
                                                
                            
                            A function pointer stores the address of a function.
Declaration: int (*fptr)(int, int);
Assignment: fptr = &add;
Call: int result = fptr(3, 4);
Used for callbacks, strategy patterns, and dynamic dispatch.
                        
                                            
                
                                
                    
                        Question 33
                        C Programming
                    
                    What is an include guard?
                    
                                                
                            
                            An include guard prevents a header file from being included multiple times:
#ifndef MYHEADER_H
#define MYHEADER_H
// declarations
#endif
This avoids duplicate definition errors during compilation.
                        
                                                
                            
                            An enum (enumeration) defines a set of named integer constants.
enum Color { RED, GREEN, BLUE };
By default, values start at 0 and increment by 1.
You can assign custom values: enum Color { RED = 1, GREEN = 5 };
                        
                                                
                            
                            printf() writes to stdout.
fprintf(fp, ...) writes to a FILE * you provide.
fprintf(stdout, ...) behaves like printf; fprintf(stderr, "Error: %s\n", msg); writes to standard error, which is typically unbuffered.
                        
                                                
                            
                            malloc(size) allocates uninitialized memory of the given size
calloc(count, size) allocates memory for an array of count elements, each of size bytes, and initializes all bits to zero
                        
                                            
                
                                
                    
                        Question 34
                        C Programming
                    
                    What is #define used for?
                    
                                                
                            
                            An include guard prevents a header file from being included multiple times:
#ifndef MYHEADER_H
#define MYHEADER_H
// declarations
#endif
This avoids duplicate definition errors during compilation.
                        
                                                
                            
                            #define creates macros — text substitutions performed before compilation.
Constants: #define PI 3.14159
Function-like macros: #define MAX(a,b) ((a) > (b) ? (a) : (b))
Always wrap macro parameters in parentheses to avoid precedence bugs.
                        
                                                
                            
                            CC = gcc
CFLAGS = -std=c11 -Wall -Wextra -O2
app: main.o util.o
  $(CC) -o $@ $^
%.o: %.c
  $(CC) $(CFLAGS) -c -o $@ $<
This compiles each .c to a .o with strict warnings, then links them into app.
Use -MMD -MP to auto-generate header dependencies.
                        
                                                
                            
                            strtol(str, &endptr, base) converts str to a long.
base may be 0 (auto-detect from 0x/0 prefix) or any value 2..36.
endptr points to the first character that was not part of the number; check it and errno for robust parsing.
                        
                                            
                
                                
                    
                        Question 35
                        C Programming
                    
                    How do you implement a dynamic array that grows on demand?
                    
                                                
                            
                            offsetof(struct S, member) returns the byte offset of member within struct S as a size_t.
Useful for binary serialization, container_of-style macros, and asserting struct layout.
The standard guarantees that the first member has offset 0.
                        
                                                
                            
                            A bit-field lets you specify the exact number of bits a struct member occupies:
struct Flags { unsigned int x : 1; unsigned int y : 3; unsigned int z : 4; };
Useful for compact storage or matching hardware registers.
Addressing a bit-field (&f.x) is not allowed.
                        
                                                
                            
                            A common pattern:int *a = NULL; size_t cap = 0, len = 0;
void push(int v) {
  if (len == cap) { cap = cap ? cap*2 : 4;
    a = realloc(a, cap * sizeof *a); }
  a[len++] = v;
}
Doubles capacity to keep amortized push O(1).
                        
                                                
                            
                            restrict on a pointer tells the compiler that no other pointer aliases the same object during the pointer's lifetime.
void copy(int *restrict dst, const int *restrict src, size_t n);
This permits aggressive optimizations like reordering or vectorizing loads/stores. Misuse (aliasing in violation) is undefined behavior.
                        
                                            
                
                                
                    
                        Question 36
                        C Programming
                    
                    What is a shared library?
                    
                                                
                            
                            %5d reserves 5 characters of width, right-aligned by default; pad with spaces.
%-5d left-aligns.
%.3f limits precision — for floats, the number of digits after the decimal; for ints, the minimum digits printed.
%5.3f combines both.
                        
                                                
                            
                            extern declares that a variable or function is defined elsewhere (in this file or another).
extern int counter; in a header lets multiple source files share the same counter.
It does not allocate storage; only the definition does.
                        
                                                
                            
                            return expr; ends the function and yields expr as its value to the caller.
Functions returning void use return; with no value.
If a non-void function reaches its closing } without a return, the behavior is undefined if the caller uses the result.
                        
                                                
                            
                            A shared library (.so on Linux, .dylib on macOS, .dll on Windows) is loaded by the dynamic linker at runtime and shared between processes.
Smaller binaries, easier updates, but introduces runtime symbol resolution.
On Linux, LD_LIBRARY_PATH influences where libraries are found.
                        
                                            
                
                                
                    
                        Question 37
                        C Programming
                    
                    How do you toggle a specific bit?
                    
                                                
                            
                            To toggle (flip) bit n:
value ^= (1 << n);
XOR with 1 flips the bit: 0 becomes 1 and 1 becomes 0, while all other bits remain unchanged.
                        
                                                
                            
                            volatile tells the compiler that a variable's value may change unexpectedly (e.g., by hardware or another thread).
volatile int sensor_val;
Prevents the compiler from optimizing away reads of the variable, ensuring it is always fetched from memory.
                        
                                                
                            
                            Static linking copies library code into the executable at build time; no dependency at runtime
Dynamic linking leaves shared libraries external and resolves symbols at startup or on first use
Static gives a self-contained binary; dynamic gives smaller binaries and easier patching but introduces the DLL hell/SONAME compatibility concerns.
                        
                                                
                            
                            Struct: each member has its own memory; size is the sum of all members (plus padding)
Union: all members share the same memory; size equals the largest member
Structs store multiple values simultaneously; unions store only one at a time.
                        
                                            
                
                                
                    
                        Question 38
                        C Programming
                    
                    What is the difference between a macro and a function?
                    
                                                
                            
                            signal(sig, handler) installs handler as the function called when the process receives signal sig.
Common signals: SIGINT (Ctrl-C), SIGTERM, SIGSEGV, SIGFPE, SIGALRM.
Inside a signal handler, only async-signal-safe functions may be called; printf is generally not safe.
                        
                                                
                            
                            Macro: textual substitution before compilation; no type checking; arguments can be evaluated multiple times; may cause code bloat
Function: real call with argument types; called once, result computed once; supports recursion
For type-generic numeric operations, C11's _Generic or inline functions are usually safer than #define.
                        
                                                
                            
                            fread(ptr, size, nmemb, fp) reads up to nmemb items of size bytes each into ptr; returns the number of full items read
fwrite(ptr, size, nmemb, fp) writes items from ptr; returns the number of full items written
Both are typically used in binary mode.
                        
                                                
                            
                            A NULL pointer is a pointer that does not point to any valid memory location.
Assigned with: int *ptr = NULL;
Always check for NULL before dereferencing to avoid segmentation faults.
                        
                                            
                
                                
                    
                        Question 39
                        C Programming
                    
                    What is snprintf() and why is it preferred over sprintf()?
                    
                                                
                            
                            snprintf(buf, n, fmt, ...) writes at most n-1 characters to buf and always null-terminates.
sprintf(buf, fmt, ...) has no length limit and is a major source of buffer overflows.
Always use snprintf; the return value tells you the length that would have been written.
                        
                                                
                            
                            memcpy(dest, src, n) copies n bytes; regions must not overlap (undefined behavior otherwise)
memmove(dest, src, n) handles overlapping regions safely by using a temporary buffer
Prefer memmove if overlap is possible.
                        
                                                
                            
                            #include <file> searches implementation-defined system paths first (for standard library and compiler headers)
#include "file" searches the current directory of the source file first, then falls back to the system paths
By convention, use <> for system headers and "" for project headers.
                        
                                                
                            
                            A bit-field lets you specify the exact number of bits a struct member occupies:
struct Flags { unsigned int x : 1; unsigned int y : 3; unsigned int z : 4; };
Useful for compact storage or matching hardware registers.
Addressing a bit-field (&f.x) is not allowed.
                        
                                            
                
                                
                    
                        Question 40
                        C Programming
                    
                    What is errno?
                    
                                                
                            
                            #pragma once is a non-standard but widely supported directive that tells the compiler to include this header only once per translation unit.
It is a simpler alternative to traditional #ifndef include guards.
Both approaches are functionally equivalent for well-formed headers.
                        
                                                
                            
                            Endianness is the order in which bytes of a multibyte value are stored in memory.Little-endian: least significant byte first (x86, x86-64, ARM in most modes)
Big-endian: most significant byte first (network byte order, some older CPUs)
Use htons/ntohs for portable network code.
                        
                                                
                            
                            int main(void) explicitly states the function takes no parameters; calling it with arguments is a compile error
int main() in C means the same in modern C; in C++ it means "takes any arguments"
In C, both declare a parameter-less function; the explicit void is clearer.
                        
                                                
                            
                            errno is a thread-local integer set by many standard library functions to indicate an error code.
Examples: ERANGE (numeric overflow), ENOMEM (out of memory), ENOENT (no such file).
You should set it to 0 before the call and check it afterward; it is only meaningful when the call signaled failure.
                        
                                            
                
                                
                    
                        Question 41
                        C Programming
                    
                    What is the difference between malloc() and calloc()?
                    
                                                
                            
                            malloc(size) allocates uninitialized memory of the given size
calloc(count, size) allocates memory for an array of count elements, each of size bytes, and initializes all bits to zero
                        
                                                
                            
                            <stdint.h> provides int8_t, int16_t, int32_t, int64_t and unsigned variants.
<inttypes.h> adds portable printf/scanf format macros like PRId32, SCNu64.
Use them when the exact bit-width matters, e.g. binary file formats or network protocols.
                        
                                                
                            
                            return n; in main returns the value to the runtime, which calls exit(n)
exit(n) terminates the program from anywhere: runs atexit handlers, flushes and closes stdio buffers, then returns n to the host
exit(EXIT_SUCCESS) is portable; EXIT_FAILURE signals failure.
                        
                                                
                            
                            fflush(stdout) writes any buffered output to the underlying file or terminal, even without a newline.
fflush(NULL) flushes all output streams.
It is defined only for output streams (or update streams in write mode); behavior on input streams is implementation-defined.
                        
                                            
                
                                
                    
                        Question 42
                        C Programming
                    
                    What is a flexible array member?
                    
                                                
                            
                            A C99 feature: a struct's last member may be declared as an array of unspecified size.
struct Buf { size_t len; char data[]; };
You allocate sizeof(struct Buf) + n bytes via malloc; data then refers to a variable-length buffer.
Allows the array to share allocation with the header, no extra pointer.
                        
                                                
                            
                            sizeof is a compile-time operator that returns the size in bytes of a type or variable.
sizeof(int) — size of an int (typically 4 bytes)
sizeof(arr) / sizeof(arr[0]) — common idiom to get array length
Note: for pointers, it returns the pointer size, not the pointed-to data size.
                        
                                                
                            
                            Functions declared void perform actions without producing a value:
void print_int(int x) { printf("%d\n", x); }
Calling print_int(5); is a statement, not an expression.
Use return; (with no value) to exit early.
                        
                                                
                            
                            Local variables are declared inside a function; they exist only while that function runs and are not visible outside.
Global variables are declared outside any function; they exist for the program's lifetime and are visible across functions (unless static).
                        
                                            
                
                                
                    
                        Question 43
                        C Programming
                    
                    What is internal vs external linkage?
                    
                                                
                            
                            size_t is the unsigned type used for sizes and counts — result of sizeof, arguments to malloc/strlen/memcpy, etc.
It is at least 16 bits and never smaller than int.
Loop counters or array indices that come from size_t should be compared with care, since they cannot be negative.
                        
                                                
                            
                            offsetof(struct S, member) returns the byte offset of member within struct S as a size_t.
Useful for binary serialization, container_of-style macros, and asserting struct layout.
The standard guarantees that the first member has offset 0.
                        
                                                
                            
                            realloc(ptr, new_size) resizes a previously allocated memory block.
It may move the block to a new location and returns the new pointer.
int *p = realloc(old_p, 20 * sizeof(int));
Always assign to a temp pointer first to avoid losing the original if realloc fails.
                        
                                                
                            
                            External linkage: the name is visible across translation units (default for non-static globals and functions)
Internal linkage: the name is visible only within its own source file (apply static at file scope)
This is how libraries hide implementation symbols.
                        
                                            
                
                                
                    
                        Question 44
                        C Programming
                    
                    What is a function prototype?
                    
                                                
                            
                            Standard C defines two prototypes:
int main(void);
int main(int argc, char *argv[]);
Returning int from main is required; the value becomes the process exit status.
                        
                                                
                            
                            fprintf() writes formatted output to a file:
fprintf(fp, "Score: %d\n", score);
fscanf() reads formatted input from a file:
fscanf(fp, "%d %s", &age, name);
Both work like printf()/scanf() but take a FILE * as the first argument.
                        
                                                
                            
                            <stdint.h> provides int8_t, int16_t, int32_t, int64_t and unsigned variants.
<inttypes.h> adds portable printf/scanf format macros like PRId32, SCNu64.
Use them when the exact bit-width matters, e.g. binary file formats or network protocols.
                        
                                                
                            
                            A function prototype declares a function's return type, name, and parameter types without providing its body:
int add(int a, int b);
It lets the compiler check call-site argument types and allows functions to be used before their definition.
                        
                                            
                
                                
                    
                        Question 45
                        C Programming
                    
                    What is a header file in C?
                    
                                                
                            
                            Automatic: block scope, lives until the block ends
Static: the entire program; covers globals and static locals
Allocated: malloc/calloc/realloc lifetime
Thread: _Thread_local, lifetime of the containing thread
                        
                                                
                            
                            A C99 feature: a struct's last member may be declared as an array of unspecified size.
struct Buf { size_t len; char data[]; };
You allocate sizeof(struct Buf) + n bytes via malloc; data then refers to a variable-length buffer.
Allows the array to share allocation with the header, no extra pointer.
                        
                                                
                            
                            Until C11 the order in which arguments to a function are evaluated was unspecified; foo(f(), g()) could call f or g first.
Since C11, every expression is sequenced: full expressions are sequenced after their operands, and operators like &&, ||, ,, and ?: introduce sequence points, so the left side is fully evaluated before the right.
                        
                                                
                            
                            A header file (.h) contains declarations of functions, macros, types, and global variables.
It provides an interface so other source files can use these features without seeing the implementation.
Example: <stdio.h> declares printf(), scanf(), etc.
                        
                                            
                
                                
                    
                        Question 46
                        C Programming
                    
                    What is the difference between the address space of code, data, stack, and heap?
                    
                                                
                            
                            The comma operator evaluates its left operand, discards the result, then evaluates and returns the right operand.
for (i = 0, j = 10; i < j; i++, j--)
It has the lowest precedence, so (a, b) + c means (a, b) + c, not a, (b + c).
                        
                                                
                            
                            A typical C process has distinct regions:Text/code: the compiled program, read-only and executable
Data: initialized globals and static variables
BSS: uninitialized globals and statics (zero-initialized)
Heap: grows up via malloc/free
Stack: grows down with each function call
                        
                                                
                            
                            A function prototype declares a function's return type, name, and parameter types without providing its body:
int add(int a, int b);
It lets the compiler check call-site argument types and allows functions to be used before their definition.
                        
                                                
                            
                            size_t is the unsigned type used for sizes and counts — result of sizeof, arguments to malloc/strlen/memcpy, etc.
It is at least 16 bits and never smaller than int.
Loop counters or array indices that come from size_t should be compared with care, since they cannot be negative.
                        
                                            
                
                                
                    
                        Question 47
                        C Programming
                    
                    What is the difference between a compiler and a linker?
                    
                                                
                            
                            Standard C defines two prototypes:
int main(void);
int main(int argc, char *argv[]);
Returning int from main is required; the value becomes the process exit status.
                        
                                                
                            
                            Compiler: translates each source file (.c) into an object file (.o) independently
Linker: combines multiple object files and resolves external references (e.g., function calls across files) to produce the final executable
                        
                                                
                            
                            A C99 feature: a struct's last member may be declared as an array of unspecified size.
struct Buf { size_t len; char data[]; };
You allocate sizeof(struct Buf) + n bytes via malloc; data then refers to a variable-length buffer.
Allows the array to share allocation with the header, no extra pointer.
                        
                                                
                            
                            sizeof is a compile-time operator that returns the size in bytes of a type or variable.
sizeof(int) — size of an int (typically 4 bytes)
sizeof(arr) / sizeof(arr[0]) — common idiom to get array length
Note: for pointers, it returns the pointer size, not the pointed-to data size.
                        
                                            
                
                                
                    
                        Question 48
                        C Programming
                    
                    What is the difference between fread() and fwrite()?
                    
                                                
                            
                            strcpy(dest, src) copies the entire source string — no bounds checking, risk of buffer overflow
strncpy(dest, src, n) copies at most n characters — safer but may not null-terminate the result if src is longer than n
                        
                                                
                            
                            getopt(argc, argv, "hv") parses command-line options one at a time, supporting short flags like -h and -v.
optarg holds the argument to an option; optind is the index of the next argv element.
POSIX provides getopt_long for long options like --help.
                        
                                                
                            
                            signal(sig, handler) installs handler as the function called when the process receives signal sig.
Common signals: SIGINT (Ctrl-C), SIGTERM, SIGSEGV, SIGFPE, SIGALRM.
Inside a signal handler, only async-signal-safe functions may be called; printf is generally not safe.
                        
                                                
                            
                            fread(ptr, size, nmemb, fp) reads up to nmemb items of size bytes each into ptr; returns the number of full items read
fwrite(ptr, size, nmemb, fp) writes items from ptr; returns the number of full items written
Both are typically used in binary mode.
                        
                                            
                
                                
                    
                        Question 49
                        C Programming
                    
                    What is the role of stdint.h versus inttypes.h?
                    
                                                
                            
                            sigaction() is the POSIX replacement for signal() with more control: explicit flags (SA_RESTART), a siginfo_t payload, and reliable semantics across platforms.
It also lets you block signals during the handler, avoiding re-entrancy issues.
Always prefer sigaction in portable Unix code.
                        
                                                
                            
                            strtol(str, &endptr, base) converts str to a long.
base may be 0 (auto-detect from 0x/0 prefix) or any value 2..36.
endptr points to the first character that was not part of the number; check it and errno for robust parsing.
                        
                                                
                            
                            A pointer is a variable that stores the memory address of another variable.
Declared using the * operator: int *ptr;
The address-of operator & retrieves a variable's address: ptr = &x;
                        
                                                
                            
                            <stdint.h> defines the exact-width integer types (int32_t, uint64_t, ...) and macros like INT32_MAX.
<inttypes.h> includes <stdint.h> and adds the PRI/SCN format macros for printf/scanf.
Use inttypes.h when you need both fixed-width types and portable format strings.
                        
                                            
                
                                
                    
                        Question 50
                        C Programming
                    
                    What does malloc() do in C?
                    
                                                
                            
                            strtol(str, &endptr, base) converts str to a long.
base may be 0 (auto-detect from 0x/0 prefix) or any value 2..36.
endptr points to the first character that was not part of the number; check it and errno for robust parsing.
                        
                                                
                            
                            #define creates macros — text substitutions performed before compilation.
Constants: #define PI 3.14159
Function-like macros: #define MAX(a,b) ((a) > (b) ? (a) : (b))
Always wrap macro parameters in parentheses to avoid precedence bugs.
                        
                                                
                            
                            Standard C defines two prototypes:
int main(void);
int main(int argc, char *argv[]);
Returning int from main is required; the value becomes the process exit status.
                        
                                                
                            
                            malloc() allocates a block of memory on the heap and returns a pointer to it.
Syntax: int *p = (int *)malloc(n * sizeof(int));
Returns NULL if allocation fails. Memory is uninitialized.



            
            
                Question navigator

What is signal() used for?

What is the difference between while and do-while loops?

What is a thread-local variable?

What does _Noreturn do?

What is the container_of pattern?

What does the C preprocessor do?

What does the getopt() function do?

What is a pointer in C?

What is the argc/argv convention?

What headers provide fixed-width integer types?

What is the difference between a struct and a union?

What does abort() do?

What is the difference between macro constants and const variables?

What is the difference between struct copy and pointer-to-struct?

What does the const qualifier do on function parameters?

What is the difference between strcpy() and strncpy()?

What does assert() do?

What are the advantages of for portability?

What is a compound literal?

What is the difference between bit-fields and bitwise operations?

What are the conversion specifiers for size_t and intmax_t in printf?

What is integer promotion in C?

What is the difference between printf() and fprintf()?

What is the associativity of assignment operators?

How does recursion work in C?

What is the difference between ++i and i++?

What is the difference between strcmp() and strncmp()?

What is the relationship between #if, #elif, and #else?

What is the register keyword?

What is the difference between recursion and iteration?

What is the difference between declaration and definition for variables?

What is typedef used for in C?

What is an include guard?

What is #define used for?

How do you implement a dynamic array that grows on demand?

What is a shared library?

How do you toggle a specific bit?

What is the difference between a macro and a function?

What is snprintf() and why is it preferred over sprintf()?

What is errno?

What is the difference between malloc() and calloc()?

What is a flexible array member?

What is internal vs external linkage?

What is a function prototype?

What is a header file in C?

What is the difference between the address space of code, data, stack, and heap?

What is the difference between a compiler and a linker?

What is the difference between fread() and fwrite()?

What is the role of stdint.h versus inttypes.h?

What does malloc() do in C?