C Programming Problem-Solving Practice Set
Uploaded by
akshatanant3C Programming Problem-Solving Practice Set
Uploaded by
akshatanant3Common questions
Powered by AIMacros in C provide several advantages like avoiding repetitive code, enhancing readability, and allowing code expansion without function call overhead. However, they have limitations such as lack of type safety, no scope, unexpected expansions resulting in errors, and debugging difficulties. In arithmetic operations, macros can simplify expressions (e.g., ADD(a, b) for a+b), but their expanded code can lead to issues if operands have side effects or are complex expressions .
Static memory allocation in C occurs at compile-time, with fixed size and lifetime, suitable for arrays and variables whose size doesn't change. Dynamic allocation happens at runtime using functions like malloc(), allowing flexible memory use based on current needs. Four differences include: 1) Static is fixed; dynamic is variable. 2) Static does not use pointers; dynamic primarily involves pointers. 3) Static memory is managed by the system; dynamic requires programmer control with malloc()/free(). 4) Static is typically faster due to predetermined size, whereas dynamic can incur overhead due to runtime allocation .
In C, a string is a sequence of characters ending with a null character '\0', while a character array is an array whose elements are characters. Strings, being null-terminated, facilitate various manipulations using standard library functions like strlen(), strcpy(), and strcat(), which are aware of the termination. Character arrays do not inherently have such capabilities unless explicitly null-terminated. These differences impact operations, memory management, and error handling (e.g., buffer overflows) in string manipulation tasks .
A switch-case statement in C is used to execute one block of code among multiple options based on the value of a variable. It's particularly useful for menu-driven programs and handling character inputs. However, its limitations include: inability to handle ranges directly, lack of support for strings or floating-point comparisons, inherent fall-through behavior without break statements, and sometimes requiring a default case for completeness. These constraints can limit its flexibility compared to a series of if-else statements .
Dynamic memory allocation in C is crucial because it allows the allocation of memory at runtime, accommodating applications where the amount of data can vary, like when the number of inputs isn't fixed. This permits efficient memory utilization, prevents wastage, and facilitates flexible data structures such as linked lists or resizable arrays. Functions like malloc() and calloc() enable dynamic management, but programmers must also manage memory deallocation with free() to prevent leaks .
The dangling else problem in C occurs in nested if statements when an else clause is ambiguously associated with the nearest if without an explicit match. It leads to confusion about which if the else part belongs to. This issue can be resolved by using braces to clearly define the block of code that each if corresponds with. For example, using if (condition) { if (another_condition) { ... } } else { ... } ensures the else is associated with the outer if statement .
Pointer arithmetic allows for direct manipulation of memory addresses, thereby facilitating efficient array traversal by incrementing pointers to access elements sequentially. This approach often enhances execution speed as it bypasses the use of index variables. However, improper pointer arithmetic, such as incrementing pointers beyond the array size, can lead to accessing harmful memory regions, causing undefined behavior, potential segmentation faults, or corruption of data, highlighting the need for cautious pointer use .
In C, call by value passes a copy of the argument's value to the function, meaning changes made inside the function don't affect the original variable. Conversely, call by address passes the address of the argument, allowing the function to modify the variable's actual value. Call by value is safer as it prevents unintended side effects, whereas call by address offers more flexibility for modifying large data structures directly, enabling efficient memory use .
Storage classes in C define the scope, visibility, and lifetime of variables. They play a crucial role in determining where variables can be accessed and how long they persist during program execution. The four primary storage classes are auto, register, static, and extern. Understanding them is essential as it affects memory management, speed optimization (register), and variable persistence across function calls (static). They help programmers manage resources efficiently and control data sharing across files using extern .
Logical operators in C (&&, ||, !) are used to combine multiple conditions, returning true or false values based on logical conjunction or disjunction. For instance, the expression (a > b && c < d) checks whether both conditions are true. Relational operators (==, !=, >, <, >=, <=) compare two values or expressions, yielding a boolean result based on the relation. For example, a > b checks if 'a' is greater than 'b'. Their usage differs as logical operators often combine results of relational expressions to form complex conditions .