Skip to content

C Programming Quick Revision Notes for GATE

Published by mayankkashyap on April 2, 2025

Aliasing

  • Definition: Aliasing occurs when two or more distinct variables refer to the same memory location (volume2_removed (9).pdf). Changing the value through one alias immediately affects the others. This typically happens with pointers or reference parameters.
  • Implication: Aliasing can cause side effects, since an update via one reference is reflected by all aliases. For example, if two pointer variables point to the same int, modifying the int via one pointer changes what the other sees.
  • Avoiding Pitfalls: Be cautious when passing the same variable to a function in multiple arguments or when using global variables; unintended aliasing can lead to bugs.

Array

  • Declaration & Memory: An array is a sequence of elements stored contiguously in memory. For example, int arr[5]; allocates 5 consecutive int slots. The array’s name represents the address of its first element (not a modifiable variable) (ebook – The C Programming Language Ritchie & kernighan -.doc) (ebook – The C Programming Language Ritchie & kernighan -.doc).
  • Array vs Pointer: In most expressions, an array name decays to a pointer to its first element. Thus, if pa is a pointer, setting pa = arr; or pa = &arr[0]; makes pa point to arr[0] (ebook – The C Programming Language Ritchie & kernighan -.doc). One key difference is that a pointer is a variable (so it can be reassigned, incremented, etc.), but an array name is not (you cannot do arr = pa or arr++) (ebook – The C Programming Language Ritchie & kernighan -.doc).
  • Indexing and Pointer Arithmetic: Array indexing is directly related to pointer arithmetic. arr[i] is equivalent to *(arr + i) (ebook – The C Programming Language Ritchie & kernighan -.doc). Likewise, &arr[i] is the same as arr + i (ebook – The C Programming Language Ritchie & kernighan -.doc). Because of this, pointer notation and array notation can be used interchangeably for traversal. For example, you can iterate through an array with either for(i=0; i<n; i++) … arr[i] … or using a pointer for(p=arr; p < arr+n; p++) … *p ….
  • Multidimensional Arrays: In C, multi-dimensional arrays are stored in row-major order (row by row contiguous). For a 2D array int A[R][C];, the address of element A[i][j] is given by &(A[i][j]) = A + i*C + j (which, as a pointer arithmetic, is equivalent to *(A+i) + j). Thus A[i][j] can be accessed by *(*(A+i)+j). All elements of a 2D array reside in one contiguous block of memory.
    • Example: If int X[4][3]; starts at address 1000 (decimal) and each int is 4 bytes, then X[2][1] is at address 1000 + (2*3 + 1)*4 = 1000 + 28 = 1028.
  • Strings: Strings in C are arrays of char ending with a null terminator '\0'. Pointer arithmetic is often used with strings. For instance, if char *p = "HELLO"; then p + 2 points to "LLO". Also, the C subscript operation is commutative: p[i] is the same as i[p] (because i[p] is defined as *(i+p), which equals *(p+i)). This unusual property can be used in pointer tricks, though it’s primarily of academic interest.
  • Usage in Functions: When an array is passed to a function, it is passed by reference as a pointer to its first element. The function’s parameter can be declared as either int f(int arr[]) or int f(int *arr) – both are equivalent inside the function (ebook – The C Programming Language Ritchie & kernighan -.doc). The function does not receive the array’s size, so that often must be passed separately if needed.

Functions

  • Basics: A function in C is defined with a return type, name, and parameters. Example: int add(int a, int b) { return a+b; }. Functions must be declared (or defined) before use. Return type defaults to int if not specified (in older C), but explicit declaration is best practice.
  • Call by Value: C uses call-by-value for passing arguments (ebook – The C Programming Language Ritchie & kernighan -.doc). This means the called function receives copies of the argument values. Any modifications to parameters inside the function do not affect the original arguments in the caller. For instance, void f1(int x) { x = 5; } will not change the original variable passed to f1. Even structures are passed by value (a copy of the struct is made). Because of call-by-value, a function like swap(int a, int b) cannot swap two variables in the caller – it only swaps the copies inside the function (ebook – The C Programming Language Ritchie & kernighan -.doc).
  • Output via Pointers: To modify a caller’s variable, pass its address (pointer) to the function. The function can then dereference the pointer to update the original. For example, void f2(int *x) { *x = 5; } can change the caller’s variable if called as f2(&var);. This is the idiom for achieving reference semantics in C.
  • Order of Evaluation: In C, the order in which function arguments are evaluated is unspecified. For example, in a call func(g1(), g2()), g1 might be evaluated before g2 or vice versa. Similarly, in an expression like x = f1() + f2(), the calls to f1 and f2 can happen in any order. Therefore, avoid writing code that depends on a particular evaluation order (especially if the functions have side effects). Sequence points (like ; end of statement, logical &&/||, , in comma operator, etc.) do impose order, but function argument evaluation order is not fixed in C. Always write functions and calls so that the result does not depend on argument evaluation order.

Goto

  • Usage: goto is a jump statement that transfers control to a labeled statement within the same function. While syntactically allowed, unrestricted use of goto is discouraged.
  • Structured Programming: Overuse of goto can lead to spaghetti code – code that is tangled and difficult to follow or maintain. Harmful Effects: It can bypass usual control structures, making reasoning about program flow harder (e.g., skipping variable initialization or cleanup). It also complicates verifying program correctness.
  • Best Practice: Use structured constructs (if, for, while, break, continue, functions) instead of goto whenever possible. Reserve goto for rare cases like breaking out of deeply nested loops or error handling that requires jumping to a common cleanup block at the end of a function.

Identify Function

(Recognizing what a given piece of code does or outputs.)

  • Code Tracing: Be prepared to trace through C code to determine its behavior or output. This often involves understanding variable scope, lifetime, and side effects. Key skills include:
    • Identifying algorithmic patterns (e.g. a sorting routine, a particular numeric computation).
    • Tracking changes to variables across function calls, especially when pointers or global variables are involved.
    • Recognizing common idioms (for example, a loop swapping adjacent elements might be a bubble sort).
  • Side Effects & Scope: For example, consider: void printXY(int x, int y) { int *ptr; x = 0; ptr = &x; y = *ptr; *ptr = 1; printf("%d, %d", x, y); } Tracing this: after x=0, ptr points to x. Then y is set to *ptr (so y becomes 0). Next *ptr=1 sets x to 1. The printf will output 1, 0. Such tracing is essential for exam questions that ask “What is the output?”.
  • Call by Value vs Reference: Recognize when a function is attempting to modify values. If a function takes arguments as values (not pointers), modifications won’t affect the caller. E.g., a function that tries to swap two ints without pointers will only swap its local copies, not the originals (ebook – The C Programming Language Ritchie & kernighan -.doc). On the other hand, a function using pointer parameters can modify caller variables. Identifying these scenarios in code helps in understanding the net effect.
  • Common Patterns: Be familiar with common functions or patterns like computing factorial or Fibonacci recursively, reversing a string/number, sorting algorithms, etc. Questions may show a snippet and ask what it computes or prints. For instance, a loop that repeatedly swaps adjacent out-of-order elements is performing a sort; if it runs to completion and then prints an element, that element might be the max or min.

Loop Invariants

  • Definition: A loop invariant is a condition that remains true before and after each iteration of a loop. It’s used to reason about algorithm correctness. For instance, in a loop summing an array, an invariant might be: “at the start of each iteration, sum holds the sum of elements processed so far.”
  • Usage: To solve questions on loop invariants:
    • Identify what remains unchanged or predictably changed each iteration.
    • Sometimes questions ask for the invariant at certain points (e.g., before loop, inside loop) or to use invariants to prove correctness.
  • Example: Consider: int j = 1; for(int i=1; i<=n; i++) { j *= i; } An invariant here is: at the start of each iteration (for a given i), j == (i-1)!. This remains true as the loop runs and helps prove that after the loop j == n!.
  • Exam Tip: Even if not explicitly asked, understanding loop invariants helps in complex loop tracing. It gives insight into what the loop is intended to do.

Output

(Determining the output of code segments.)

  • Print statements: Many C questions present a code snippet and ask for its output. Key points to consider:
    • Format specifiers: Ensure you match the printf format with the variable types. %d for int, %c for char, %s for string, %u for unsigned, etc.
    • Character arithmetic: Remember that chars are essentially small integers (ASCII codes). Bitwise or arithmetic operations on char produce int results in C (due to integer promotion). For example, 'A' + 2 results in an int value 67 (if ‘A’ is 65), which corresponds to ‘C’ when converted back to char.
    • Bitwise operations on chars: If you see code using &, |, ^ on characters, they are operating on the ASCII codes. For instance: char a = 'P', b = 'x'; char c = (a & b) + '*'; Here a & b performs bitwise AND on the char codes of ‘P’ and ‘x’, producing an int result. Adding ‘*’ (the char code for asterisk) then converting to char yields some character. To solve, use given ASCII values or reasoning if provided.
    • Static variables: A static local variable retains its value between function calls. This often shows up in output questions: int func() { static int x = 1; x++; return x; } int main() { int a = func(); // x becomes 2, returns 2 -> a=2 int b = func() + a; // x becomes 3, returns 3, then b = 3+2 = 5 printf("%d\n", a + b); // prints 2+5 = 7 } Understand that x is incremented each time func is called, and it preserves its value between calls.
    • Loops and termination: Watch for loops that might not terminate properly or that produce tricky output. E.g., a while loop that doesn’t update the loop variable correctly can cause an infinite loop or unexpected output. If a question includes such a loop, consider edge conditions. For example: int a=6, b=0; while(a < 10) { a = a/12 + 1; a += b; } printf("%d", a); Here a becomes 1 in the first iteration and then never changes (because 1/12 + 1 remains 1), causing an infinite loop. The program would never reach the printf. On an exam, an option might state “program does not terminate” for such cases.
    • Recursion in output: Some output questions involve recursive functions that print characters (often to reverse a string or similar). Understand how recursion unwinds. For example, a function that reads characters until newline and then prints them after the recursive call will print the string in reverse. Ensure you can simulate the recursion for small inputs to see the output.
  • Precision: For numeric output, make sure to consider types. For instance, printing a pointer with %u (unsigned) will show its address in numeric form. Printing a large value into a smaller format (like an int into %short if it were possible) could truncate or give unexpected results – usually the compiler warns or it’s not allowed without a cast.

Parameter Passing

  • Call by Value: C passes parameters by value (always!). Each function argument is evaluated and its value is copied into the corresponding parameter variable of the function (ebook – The C Programming Language Ritchie & kernighan -.doc). Therefore, modifications to parameters inside the function do not affect the caller’s variables (they are different memory). This applies to all types (basic types, structs, pointers (the pointer value is copied), etc.).
  • Simulating Call by Reference: To allow a function to modify a variable in the caller, you must pass a pointer (the address of the variable). The function then dereferences the pointer to access or modify the original variable. For example: void incr(int *p) { (*p)++; } // increments the value pointed to by p ... int x = 5; incr(&x); // x becomes 6
  • Common parameter passing scenarios:
    • Swap function: A classic example: void swap(int a, int b) { int temp = a; a = b; b = temp; } This will not swap the caller’s variables, since only copies were swapped (ebook – The C Programming Language Ritchie & kernighan -.doc). To swap caller variables, use pointers: void swap(int *a, int *b) { int temp = *a; *a = *b; *b = temp; } Then call as swap(&x, &y);.
    • Passing arrays: When you pass an array to a function, it decays to a pointer to its first element. Thus, the function can modify the array’s contents. This is effectively call by reference for each element of the array. (The pointer itself is passed by value, but it points to the original memory.)
    • Constant arguments: If you pass a constant or an expression (e.g., func(num1+3)), the function receives the value of that expression. You cannot directly modify the caller’s operand because it isn’t a variable. For example, func(x+1) inside cannot alter x outside.
  • Macro vs Function (Call by Name): Be aware of C preprocessor macros which behave differently. A macro like: #define swap_macro(a,b) { int t=a; a=b; b=t; } performs textual substitution. It does not evaluate its arguments in a single, well-defined context. If used as swap_macro(x, y), it works for variables x and y. But if used with expressions (e.g., swap_macro(a[i], a[j])), the expressions can be evaluated multiple times unexpectedly. This is analogous to call-by-name (each occurrence is substituted). In contrast, a proper function swap_func(int *x,int *y) evaluates its arguments once (addresses) and swaps reliably via those pointers.
  • Call-by-Reference vs Call-by-Name (theoretical): Some questions may ask where call-by-reference and call-by-name would differ in outcome. Generally:
    • Call-by-reference evaluates the arguments once and the function operates on the aliased variables.
    • Call-by-name (like macro or Algol’s style) textually substitutes the argument expression into the function body, which can cause the argument to be evaluated multiple times. They yield different results if the argument has side effects or if the same variable is passed to multiple parameters. For example, in a hypothetical call-by-name scenario, passing i (a variable) for two different parameters that the function swaps might actually swap i with itself twice (depending on how substitution is done), whereas call-by-reference would truly alias both parameters to the same variable (and likely only one swap effectively does nothing). In C, you mainly encounter this in macros. Key takeaway: In C, stick to understanding that normal functions are call-by-value, and use pointers for reference semantics.

Pointers

  • What is a Pointer: A pointer is a variable that stores the memory address of another variable. For example, int *p; means p can hold the address of an int. If int a = 5; p = &a;, then *p (dereference) is the value of a (here 5).
  • Pointer Operations:
    • You can assign one pointer to another if they have the same type: q = p; makes q point to whatever p points to.
    • Dereference: *p yields the variable pointed to by p. It can be used to read or modify: *p = 10; would set a = 10 in the above example.
    • Address-of: &var gives a pointer to var. Only variables (and array elements) have addresses. You cannot do &(a+1) if a is an int expression (but you can do &(arr[i]), which is essentially arr + i as discussed).
  • Pointer and Array Relationship: As noted, pointers and arrays are closely related. If arr is an array, then arr (in expressions) acts like a pointer to its first element, and arr[i] is defined as *(arr + i) (ebook – The C Programming Language Ritchie & kernighan -.doc). Likewise, if p is a pointer, you can use indexing: p[i] is the same as *(p + i) (ebook – The C Programming Language Ritchie & kernighan -.doc).
  • Pointer Arithmetic: If p points to an element of an array, p+1 points to the next element (of the same array) (ebook – The C Programming Language Ritchie & kernighan -.doc). In general, p + n points to the n-th element after p. The distance in bytes moved is n * sizeof(type). Subtracting pointers (within the same array) gives the number of elements between them. For instance, if p and q point into the same array, q - p yields how many elements q is ahead of p. (Pointer subtraction is only valid for pointers into the same array or one past the last element.) Pointer comparisons (==, <, >, etc.) are also only valid within the same array.
    • Example: If double a[2] = {20.0, 25.0}; and double *p = a, *q = a+1; then q - p is 1 (they are one element apart), and *q - *p is 25.0 - 20.0 = 5.0. In an expression, (int)(q-p) would be 1 and (int)(*q - *p) would be 5.
  • Null and Dangling Pointers: A null pointer is a pointer that points to nothing valid. It’s usually represented by NULL (which is ((void*)0) or simply 0 in pointer context). Dereferencing a null pointer causes a runtime error. Always initialize pointers, either to a valid address or to NULL if not pointing anywhere yet. A dangling pointer arises when the memory it pointed to is freed or goes out of scope. For example, returning a pointer to a local variable from a function causes a dangling pointer (the local variable ceases to exist after function returns). Using a dangling pointer is undefined behavior.
  • Pointer to Pointer: You can have pointers to pointers (e.g., int **pp;). These are useful when you need to modify a pointer in a function (simulate pass-by-reference for pointer variables) or for multidimensional dynamic arrays. For example, void setNull(int **p) { *p = NULL; } can set a passed-in pointer to NULL.
  • Function Pointers: C allows pointers to functions, with types like int (*fptr)(int, int). They are used for callback functions or passing functions as arguments. Syntax can be tricky: e.g., int (*f)(int*) is a pointer to a function taking int* and returning int (volume2_removed (9).pdf). Using function pointers is more advanced, but key is to understand the declaration syntax.
  • Void Pointer: void * is a generic pointer type that can hold the address of any data type. You cannot directly dereference a void* (because it has no type), so you must cast it to the appropriate type first. malloc and other memory allocation functions return void* which is then cast to the desired pointer type.
  • Pointer Safety Tips:
    • Always ensure pointers point to valid memory before dereferencing.
    • When using dynamic memory (with malloc/free), keep track of allocated pointers. Freeing memory and then continuing to use the pointer leads to dangling pointer issues.
    • Pointer arithmetic should remain within the bounds of the array. Accessing memory outside array bounds is undefined behavior (even if it might sometimes read some value, it’s not reliable).
    • If two pointers point to the same array, subtracting them yields a valid difference. But adding two pointers, or adding a float to a pointer, etc., is invalid (ebook – The C Programming Language Ritchie & kernighan -.doc).
    • Pointer and const: If you see const int *p, it means you cannot modify the value pointed by p (treat it as read-only), but you can change p itself to point elsewhere. Conversely, int * const p means the pointer p cannot point anywhere else after initialization, but you can modify the value it points to. Be mindful of such const correctness in function signatures.
  • Examples:
    • Swapping two variables via pointers (see Parameter Passing section).
    • Building a linked list using structures and pointers: struct Node { int value; struct Node *next; }; struct Node *head = malloc(sizeof(struct Node)); head->value = 0; head->next = NULL; Here head is a pointer to a struct. head->value accesses the value field of the struct it points to, and head->next is a pointer to the next node. Always set the next of the last node to NULL; failing to do so can leave an indeterminate pointer (dangling) that can cause runtime errors if accessed.
    • Pointer arithmetic and struct fields: struct Ournode { char x, y, z; } p = {'1','0','c'}; struct Ournode *q = &p; printf("%c %c", *((char*)q + 1), *((char*)q + 2)); Here (char*)q treats the address of p as a char* (byte-wise). Adding 1 and 2 moves that pointer by 1 and 2 bytes, respectively. This prints the second and third bytes of p (which correspond to y and z). If p.x='1', p.y='0', p.z='c', the output will be 0 c. This illustrates how struct fields are laid out contiguously in memory (with possible padding).
  • Common Pointer Pitfalls:
    • Using an uninitialized pointer (often a cause of segfault). Always initialize pointers, e.g., set to NULL or to a valid address.
    • Dereferencing a pointer that doesn’t point to a valid object (null or freed memory).
    • Not allocating enough memory and then writing beyond allocated space (buffer overflow).
    • Forgetting to free dynamically allocated memory (memory leak), or freeing too soon (dangling pointer).
    • Misunderstanding pointer precedence in complex expressions. For example, in *p++, the ++ applies to p (post-increment) not to *p (because *p++ is parsed as *(p++)). Use parentheses if needed for clarity.

Programming Constructs

  • Basic Constructs: The fundamental programming constructs are sequence (executing statements in order), selection (making choices – if/else, switch), and iteration (loops – for, while, do-while). Any algorithm can be constructed using these (this is the structured programming theorem).
  • Structured Programming Goal: To write programs using only the above constructs (and function calls) without arbitrary jumps (goto), to improve clarity and maintainability. In structured programming:
    • Every loop has a single entry and exit.
    • Selection has clear alternatives (like the branches of if or switch).
    • This makes it easier to reason about program flow.
  • Recursion vs Iteration: Recursion is another way to achieve repetition (iteration) through repeated function calls. Anything done with loops can be done with recursion, but one might be clearer than the other in different situations.
  • Compound Statements: In C, { ... } is used to group multiple statements into one block so it can be treated as a single statement in selection or iteration constructs.
  • Infinite Loops and Break: Be mindful of loop conditions. A for or while that never breaks or reaches a false condition is an infinite loop (unless it has an internal break). Use break to exit loops early, and continue to skip to the next iteration.
  • Example: A typical construct usage: // find max in array int max = arr[0]; for(int i=1; i<n; i++) { if(arr[i] > max) { max = arr[i]; } } This uses sequence (initialization of max), iteration (for loop), and selection (if) inside the loop.

(The question associated with this category seemed theoretical, possibly about halting problem or language expressiveness. In context of C programming prep, focus on understanding and using these constructs correctly.)

Programming in C

(Miscellaneous C concepts and common pitfalls.)

  • Static Variables in Functions: A static local variable retains its value between calls. It’s initialized only once. Use cases: counting function calls, caching results, etc. Be aware that it also means the function is not reentrant (it can’t be safely used in multiple threads or recursive calls if the static is modified).
  • Global Variables: Global variables are visible throughout the program (after their declaration). In C, if not initialized explicitly, global and static variables are initialized to 0 (or NULL for pointers) by default. The scope of a global is the entire program (if not static global, which would limit it to that file). Modifying globals can have side effects across functions. (C uses static scoping, meaning a global variable x will be overshadowed by a local x inside a function, but if that function calls another which uses x and doesn’t have its own, it refers to the global.)
  • Recursion and the Stack: Each recursive call in C creates a new stack frame (activation record) for the function. If recursion doesn’t terminate (no base case met), it can cause a stack overflow (runtime crash) because frames keep allocating. Ensure every recursive function has a proper base condition that will eventually be reached.
  • Activation Records: At runtime, function calls use a stack. The activation record (or stack frame) holds the function’s local variables, parameters, and return address. For nested calls, multiple activation records exist on the stack. (There is no fixed limit like “at most one between current and main” – it depends on call depth, so statement B in a certain question was likely correct: the number of activation records depends on the calling sequence.)
  • Memory Layout: Understand that local variables (non-static) are on the stack, global and static variables are in a static area, and dynamic allocations (malloc) are on the heap. Variables have lifetimes corresponding to these: local exists only during the call, static/global exist for the program duration, dynamic exists until freed.
  • Type Systems: C is statically typed (types are checked at compile time). Each variable has a fixed type, and converting between types may require casts. There is no automatic runtime type checking for basic types (e.g., you can cast an int pointer to a float pointer, but using it is likely incorrect). In contrast, dynamically typed languages (like Python) determine types at runtime. In C, every value has a type and every variable has a specific type – there are no “untyped” values. (Even a void* has the type “pointer to void”, meaning type info is not known through it, but the value is still a memory address.)
  • Type Casting: You can explicitly convert (cast) between types, e.g., (float)intVar to get a float, or (int*)ptr to treat a pointer of one type as another. Use casts when necessary but carefully – an improper cast can violate the type system and lead to undefined behavior if you interpret data as the wrong type.
  • Const Correctness: The keyword const can apply to variables and pointer targets. Understand that const int *p means you cannot change *p (the pointed value) via p, whereas int * const p means you cannot change the pointer p itself (to point elsewhere), but you can change the value it points to. const int * const p would mean neither the pointer nor the pointed value can be changed (via that pointer).
  • Volatile: A less common keyword, volatile, tells the compiler that a variable may change unexpectedly (like hardware registers or shared memory). It prevents certain optimizations that assume a variable won’t change on its own.
  • Conditional Operator: Ternary operator ?: is a shorthand for if-else that yields a value. Example: max = (a>b) ? a : b; chooses the larger of a and b.
  • Switch Cases and Break: In a switch statement, cases fall through by default. Use break to prevent falling through to the next case. If a switch case doesn’t have a break, execution continues into the next case’s statements. This is sometimes used intentionally, but often a source of bugs if break is forgotten.
  • Enums: Enumeration types (enum) assign names to integral constants, improving code readability. Example: enum Color { RED=1, GREEN=2, BLUE=3 }; then enum Color c = GREEN;.
  • Preprocessor: The C preprocessor handles directives like #include, #define, #if. Remember:
    • #define for constants and macros (no semicolon at end, purely textual substitution).
    • Use parentheses in macro definitions to avoid precedence issues (e.g., #define SQR(x) ((x)*(x))).
    • #include literally inserts the contents of the header file.
    • You can use #if and #ifdef for conditional compilation.
  • Standard Library: Be aware of commonly used <stdio.h> functions (printf, scanf, gets(unsafe), fgets, getchar, putchar), <stdlib.h> (malloc, free, atoi, etc.), <string.h> (strlen, strcpy, strcmp, etc.), <math.h> (math functions).
  • Common Pitfalls Recap:
    • Off-by-one errors: e.g., iterating one time too many or too few, accessing arr[arr_size] (which is out of bounds) instead of arr[arr_size-1].
    • Using = instead of ==: inside an if or loop condition. if(x = 5) { ... } assigns 5 to x and then checks if x (5) is true – which it is, so the block always executes. This is a logical error; it should be == for comparison.
    • Operator precedence: Know that *p++ increments the pointer (not the pointee), *p+1 adds 1 to the pointee value (but does not change it), *(p+1) gives the next element. Use parentheses to clarify: e.g., (*p)++ increments the value pointed by p.
    • Integer division and promotion: In C, 5/9 equals 0 (integer division). Write 5.0/9.0 or at least one operand as float to get floating result. Also, smaller types (char, short) promote to int when used in expressions.
    • Signed vs Unsigned: Mixing signed and unsigned can lead to unexpected results (because of how conversion rules work). For example, if unsigned int u = 1; int i = -2; then if(i < u) might be false because i is converted to unsigned (large positive) before comparison.
    • Memory allocation: Always ensure allocated memory is sufficient and freed when no longer needed. A memory leak (not freeing memory) won’t affect program output immediately but is a resource issue. Double freeing or freeing memory not allocated by malloc is undefined behavior.

(The “Programming in C” category is broad; ensure you have a solid grasp of the C language basics and the specifics mentioned above for a strong foundation to tackle any question.)

Programming Paradigms

  • Procedural Programming: (C is primarily procedural.) Programs are organized into procedures (functions) that operate on data. Emphasizes a clear sequence of commands. State is stored in variables, and procedures modify that state.
  • Object-Oriented Programming: Organizes code into objects that encapsulate state and behavior. (Not a native paradigm in C, but achievable via structures and function pointers if needed.) Key concepts: encapsulation, inheritance, polymorphism. In C++ or Java, you’d use classes; in C, you manually manage structures and related functions.
  • Functional Programming: Emphasizes immutable data and pure functions (no side effects). Uses functions as first-class citizens. While C is not functional, you can apply some principles (like using functions without side effects). Languages like Haskell or Lisp are examples of this paradigm.
  • Logic Programming: Uses logic and facts/rules to derive conclusions (e.g., Prolog). Not applicable in C directly.
  • Structured vs Unstructured: Structured programming (mentioned earlier) avoids goto and uses the constructs of sequence, selection, iteration, and recursion. Unstructured would be heavily relying on jumps/goto.
  • Scripting vs System Programming: C is often used as a system programming language (close to hardware, manual memory management). Scripting languages (Python, Bash) are higher-level and manage memory and types dynamically.
  • Multi-paradigm in C: While C is procedural, you can use different styles: for instance, treat functions as values (to mimic functional style with qsort’s function pointers), or group data and functions operating on it (a rudimentary form of object orientation).
  • Exam context: If a question asks about paradigms, e.g., matching programming styles to characteristics, remember:
    • Imperative (procedural): uses statements that change program state (C, Fortran).
    • Declarative: describes what outcome is desired, not how to achieve it (SQL, logic programming).
    • Object-oriented: organizing code into objects (C++, Java).
    • Functional: uses functions and avoids state (Haskell, Scheme).

Recursion

  • Definition: Recursion is when a function calls itself. A recursive function typically has:
    • A base case that does not make a recursive call (to terminate recursion).
    • A recursive case that breaks the problem into a smaller subproblem, calling itself.
  • Example: Factorial: int fact(int n) { if(n <= 1) return 1; // base case else return n * fact(n-1); // recursive step } Each call to fact with n>1 calls fact(n-1) until it eventually hits fact(1) or fact(0) which returns 1.
  • Tracing Recursion: To understand a recursive function, simulate the call stack:
    • Each recursive call has its own set of local variables.
    • Values are returned back down the chain of calls.
    • For output, note that recursion can print items on the way down (before recursive calls) or on the way up (after recursive calls). For example, a function that first calls itself and then prints will print in reverse order of the calls.
  • Common Recursive Patterns:
    • Mathematical sequences (factorial, Fibonacci – though Fibonacci naive recursion is expensive exponential time).
    • Divide and conquer algorithms (quick sort, merge sort, binary search – though binary search can also be done iteratively).
    • Tree traversals (naturally recursive structures).
    • Backtracking algorithms (like generating permutations, solving puzzles).
  • Tail Recursion: A special case where the recursive call is the last thing in the function. e.g., int tail_rec_sum(int n, int accum) { if(n == 0) return accum; else return tail_rec_sum(n-1, accum + n); } Tail recursion can be optimized by some compilers to loop-like performance (though standard C compilers may not guarantee tail call optimization).
  • Recursion vs Iteration: Anything you do recursively, you can do iteratively (using loops and possibly an explicit stack). However, sometimes recursion leads to simpler code for naturally recursive problems (like traversing a tree or graph).
  • Stack Overflow in Recursion: If a recursion is uncontrolled (no proper base case or it calls itself in a way that doesn’t reduce the problem), it will eventually overflow the call stack (too many nested calls). Always ensure progress toward a base case.
  • Multiple Recursion: Some functions call themselves multiple times (e.g., recursive Fibonacci: fib(n-1) + fib(n-2)). This can blow up in the number of calls (exponential time). Be mindful of the complexity.
  • Memoization: An optimization for recursive solutions – store results of subcalls to avoid recomputation (common for Fibonacci and other overlapping subproblem recurrences).
  • Example Question context: A question might show two versions of a recursive function and ask which is more efficient (e.g., one computes Fibonacci recursively vs one using a loop or memoization). Identify if the recursion overlaps subproblems or if it’s straightforward.
  • Use of Recursion in C: C allows recursion as long as there is stack space. There is no special syntax; just ensure to have a termination condition. Also note that very deep recursion (thousands of levels) might crash due to limited stack (this is environment-dependent).
  • Scope and Recursion: If a function uses a global variable or static, those persist across recursive calls (they are not reinitialized each time). This can sometimes be used but often should be avoided or carefully managed to prevent interference between calls.

Structure

  • Definition: A struct in C is a user-defined composite type that groups variables under one name. Example: struct Point { int x; int y; }; struct Point p1; p1.x = 3; p1.y = 4; Here Point has two fields x and y.
  • Memory Layout: The fields of a structure are stored in the order of declaration, with possible padding for alignment. In memory, &p1 gives address of the start of the struct, &p1.x is the same as (struct Point*)&p1 + 0 essentially, and &p1.y is a higher address. If char fields or other small types are present, the compiler might insert padding to align them (commonly, struct members aligned to multiples of their size or target architecture requirements).
  • Accessing Members: Use the dot . operator for direct struct variables (e.g., p1.x). Use the arrow -> operator for pointers to struct (e.g., struct Point *ptr = &p1; ptr->x is the same as (*ptr).x).
  • Array of Structures: E.g., struct Node nodes[10]; is an array of 10 Node structures. You can iterate and treat it like any array (each element is a struct). nodes[i].field accesses a field in the i-th struct.
  • Pointer to Struct Array: If struct Node arr[10]; struct Node *p = arr;, then p->field refers to arr[0].field, and p+1 points to arr[1] (advances by sizeof(struct Node)). So (p+1)->field is arr[1].field.
  • Nested Structures and Unions: Structures can contain other structures or unions. Access via chaining the dot/arrow: struct A { int x; }; struct B { struct A a; int y; }; struct B b; b.a.x = 5; // access nested struct field
  • Unions: A union is similar to a struct in syntax, but all members share the same memory. The size of a union is the size of its largest member. You can only use one member at a time (setting one member’s value and then reading another without setting it is undefined behavior). Unions are often used for type punning or interpreting the same memory in different ways.
    • Example: union U { float f; long l; } u; u.f = 3.14f; // now u.l contains the raw bit pattern of that float interpreted as a long This is low-level and generally non-portable, but demonstrates union usage.
  • Sizeof Structs:sizeof(struct SomeStruct) gives the total size including padding. For example: struct { short x[5]; union { float y; long z; } u; } t; If short is 2 bytes, float 4 bytes, long 4 bytes (assume 32-bit system), then:
    • x[5] takes 10 bytes.
    • Union u takes max(4,4) = 4 bytes.
    • Without alignment, total would be 14 bytes (volume2_removed (9).pdf).
    • With typical alignment, the struct might pad x[5] to a multiple of 4 (to align the union) – it would pad 10 bytes to 12, then add 4 for the union = 16 bytes. Always be mindful of alignment when calculating sizeof.
  • Typedef with Struct: You can typedef struct { ... } MyType; to create an alias without needing to write struct every time. Or typedef struct Node Node; so you can refer to Node instead of struct Node.
  • Passing Structs: Structs can be passed to functions (they will be copied), but if a struct is large, it might be more efficient to pass a pointer to it. You can also return structures from functions (C99 and above, and practically in C89 too, returning structs is allowed).
  • Memory Allocation for Structs: Use malloc(sizeof(struct MyStruct)) to allocate memory for a struct dynamically. It returns a void* which you cast to your struct pointer. Always check if allocation succeeded (non-NULL) and eventually free it.
  • Common Mistakes:
    • Forgetting to allocate memory for pointers inside structs that should point to dynamic data (for example, a struct containing a char * where you intend to store a string – you need to allocate space for the string or point it to an existing string).
    • Assuming structure packing – padding might cause unexpected sizeof. Use #pragma pack or compiler-specific directives if you need to tightly pack (rarely needed in typical scenarios).
    • Copying structs: You can assign one struct to another if they are the same type (this copies all members). This is often easier than copying each field.
  • Example of struct usage: struct Person { char name[50]; int age; }; struct Person p = {"Alice", 30}; printf("%s is %d years old\n", p.name, p.age); This creates and uses a struct. If you had an array of Person, e.g. struct Person people[2];, you could do people[0] = p; to copy the struct into the array element.
  • Self-referential Structs (Linked Structures): A struct can have a pointer to a struct of the same type (for linked lists, trees, etc.). E.g., struct Node { int data; struct Node *next; }; You then create nodes and link them. Always set the next of the last node to NULL. If you iterate beyond, you might dereference a garbage pointer. A common error is forgetting to initialize a new node’s next or forgetting to update next properly, leading to stray pointers or loops.

Switch Case

  • Syntax: switch (expr) { case C1: ...; break; case C2: ...; break; default: ...; } The expr is evaluated once, then compared to each case label (which must be compile-time constant int or char). If a match is found, execution jumps to that case.
  • Fall-through: If a case block does not end in break (or a return or goto), execution will continue into the next case’s code. This is often unintentional. For example: char ch = 'A'; switch(ch) { case 'A': printf("Choice A\n"); case 'B': printf("Choice B\n"); break; default: printf("No Choice\n"); } Here, 'A' matches case ‘A’: it will print “Choice A”, then fall through into case ‘B’, print “Choice B”, then hit break. It will not execute the default in this scenario. The output would be: Choice A Choice B If 'B' was the value, it would print “Choice B” then break (no “Choice A”). If none of the cases match, default (if present) executes. If a break is missing on a case that isn’t meant to fall-through, it’s a bug.
  • Use of Default: default case handles any value not matched by an explicit case. It’s optional but good to include to cover unexpected values.
  • Multiple cases same code: You can stack case labels: switch(x) { case 1: case 2: case 3: printf("x is 1, 2, or 3\n"); break; default: printf("x is something else\n"); } Here 1, 2, 3 all result in the same print (this works because of fall-through behavior intentionally used).
  • Enumerations in switch: If using an enum, you can use its constants in switch cases. It’s wise to have a case for every enumerated value or a default.
  • Switch vs If-Else: A switch is generally used when you have a variable compared against many constant values. It can be more efficient (compiler may use jump tables) and clearer than a long if-else chain.
  • Scope in Cases: Variables declared inside a case without braces have slightly tricky scope rules. Best practice: put braces after case labels if you declare new variables: switch(n) { case 0: { int y = 5; foo(y); } break; ... } Otherwise, a declaration in one case is visible in subsequent cases (which can cause errors if not handled carefully).
  • No Floating in switch: The case labels must be integer constant expressions (or something that evaluates at compile time to int/char). You cannot switch on a string in standard C (you’d use if-else or an array of string comparisons), nor on a float/double.
  • Example Pitfall: Forgetting a break: int n=1; switch(n) { case 1: printf("One\n"); case 2: printf("Two\n"); default: printf("Default\n"); } Output: One Two Default because of fall-through. To correct, add break; after “One\n”.
  • ‘break’ vs ‘return’: A return inside a case will also exit the switch (and the function). Sometimes used if the job is done. A break only exits the switch (not the loop if the switch is inside one).
  • Switch in Loops: It’s fine to use switches inside loops. A break in switch will break out of the switch, not the loop. To break the loop from inside a switch, you might use a flag or a goto label outside the loop, or restructure logic (or use return to break out of everything if in a function).

Type Checking

  • Static Typing in C: C is statically typed. This means that type checking is done at compile time. Each variable has a type that does not change at runtime, and operations are checked for type compatibility when compiling. For example, you cannot assign a double to an int* without a cast – the compiler will error.
  • Weak vs Strong typing: C is sometimes described as having a “weak” type system because it allows explicit casts to override the type system (you can cast any pointer to any other pointer type, for instance). However, it’s strong enough to catch many errors if you don’t cast away types.
  • Implicit Conversions: The compiler will perform standard conversions in expressions (e.g., char to int, or int to double if needed). But it won’t automatically convert an int to a pointer or vice versa – that’s a type error (unless you cast, which you should do carefully if at all).
  • Function Prototypes and Type Checking: In C, having a function prototype visible before a call ensures the compiler checks that the number and types of arguments match the function’s parameters. If you call a function with the wrong types and there’s no prototype, the compiler might implicitly declare the function (C89 rules) and assume a return int, which can lead to runtime errors. Always include proper prototypes (by including headers or declaring before use) to enable compile-time checking of function calls.
  • Const correctness: The compiler will enforce that you don’t assign a const pointer to a non-const pointer without a cast, or call a function with a const argument when it expects a non-const (since that could allow the function to modify something that shouldn’t be modified).
  • VOID pointers: A void* can be assigned to any data pointer and vice versa (implicitly in C, unlike C++ which requires cast). This is an exception in type checking (to allow generic code like memory allocation). Converting between function pointers and void* is not permitted without a cast – and even with a cast, it’s not portable to do so.
  • False Statements Example: If confronted with statements about type systems:
    • “In dynamically typed languages, variables have no types” – This is misleading/false: in dynamic typing, variables can hold values of any type, but values themselves do have types at runtime.
    • “In un-typed languages, values do not have any types” – Also misleading: an un-typed or weakly typed language (like some assembly-like or BCPL) might not enforce types, but any value in memory can be interpreted somehow (bits don’t carry type info, but operations impose an interpretation).
    • Remember: In C (statically typed), each variable’s type is fixed and each value in an expression has a type known at compile time (after applying rules of promotion). This is an asset as K&R say, leading to fewer runtime surprises (ebook – The C Programming Language Ritchie & kernighan -.doc). Type checking catches mismatches early (e.g., assigning a pointer to an int without cast is compile error).
  • Casts and Type Safety: A C cast, e.g. (int*)someFloat, tells the compiler “trust me, I know what I’m doing.” It will convert the bit pattern of someFloat to be interpreted as an address. This is almost always wrong to do. Only cast when necessary (e.g., from void* to the appropriate type after malloc, though in C this cast is implicit, or when using polymorphic data structures). Overusing casts can mask real type errors.
  • enum types: These are basically integers under the hood. The compiler will allow an enum to be used as an int (with possible warnings), and vice versa. Some type checking is lost here (C++ is stricter with enum class, but in C, enums are just ints).
  • Volatile and Type: The volatile qualifier doesn’t affect type compatibility much, but the compiler won’t optimize accesses to volatile variables (it always reads from memory, because the value might change externally).
  • Overall: Write code so that types match. Most IDEs or compilers with warnings (-Wall) will alert if you pass the wrong type to a function or assign incompatible types.

Union

  • What is a Union: A union is a special structure that allows different fields to share the same memory. You define it similarly to a struct, but it allocates enough space for the largest member, and all members start at the same address. union Data { int i; float f; char str[20]; } u; Here, u.i, u.f, and u.str all overlap. Writing to u.i and then reading u.f reinterprets the bits of the integer as a float (which is generally undefined behavior unless it’s part of a specific use-case like bit-level operations).
  • Size and Alignment: The size of a union is at least the size of its largest member (it may be padded to meet alignment requirements of that member). E.g., if a union has an int (4 bytes) and a double (8 bytes), sizeof(union) will be 8 (assuming 8 is largest and properly aligned).
  • Use Cases:
    • Unions are used in implementations of variant data types, where a value could be one of several types and a separate tag indicates which is active (common in C programs to implement something akin to a variant or polymorphic type).
    • They are used when interpreting the same memory in different ways, for example in low-level code: union { uint32_t u32; uint8_t bytes[4]; } converter; converter.u32 = 0xAABBCCDD; // Now converter.bytes[0]..[3] give the individual bytes (endian-dependent). This can be used to easily extract bytes from a 32-bit integer, though type-punning through unions is technically allowed in C (C99 and later allow reading from the last written member or any member if the content is common initial sequence in structs, but exact rules can be tricky – however, using union for type punning is a common idiom in C and is safer than casting pointers).
    • In embedded programming, unions are used to map hardware registers or memory overlays.
  • Accessing Members: Only one member of a union can be used at a time in a well-defined way. You can assign to one member and then read from the same member safely. Reading from a different member than was last written is implementation-defined (some compilers might allow certain cases, but it’s not strictly portable except for the aforementioned type-punning usage which the C standard allows in certain conditions).
  • Example: union Number { int i; double d; } num; num.d = 3.14; printf("%d\n", num.i); // interpreting the double bits as int - not meaningful In practice, this will print some integer corresponding to the bit pattern of 3.14 in IEEE-754, which is usually not useful. This would be considered an incorrect use unless intentionally doing bit-level hacks.
  • Memory Consideration Example: For the declaration: struct { short x[5]; union { float y; long z; } u; } t; If short=2 bytes, float=4, long=4 bytes:
    • The array x[5] is 10 bytes.
    • The union u is 4 bytes (since max(4,4)=4).
    • Without alignment, size would be 14 bytes (volume2_removed (9).pdf).
    • With typical alignment (assuming struct aligned to max member which is 4 bytes), x array might get padded to 12, then union 4 making total 16 bytes.
    • The answer to “memory requirement ignoring alignment” is 14 bytes (just sum in this case) (volume2_removed (9).pdf).
  • Tagged Union Pattern: Often implemented in C as: struct Variant { enum { INT_TYPE, FLOAT_TYPE, STR_TYPE } type; union { int i; float f; char *s; } data; }; Here, type indicates which member of the union is valid in data. You must set type and then use the corresponding union member. This is a common safe usage of unions.
  • Union vs Struct: A struct allocates all members (and you can use all at once), whereas a union allocates one shared space for all members (and you use one at a time). Use struct when you need multiple pieces of data at once, use union when data can be one of many forms and you only need to store one form at a time (saving space).
  • Endianness Concern: When using unions to interpret bytes, remember endianness (byte order) can affect how multi-byte values appear in memory.
  • Exam Tips: If asked, “what is the size of union X”, identify the largest member (taking into account if it’s an array, compute total array size). If alignment is ignored, just use raw sizes. If not, align to the largest member’s alignment.

Variable Binding

  • Binding and Scope:Binding refers to the association of variables with their values or scopes. In C:
    • Static (Lexical) Scope: C uses lexical scoping. A variable’s scope is determined by the program text. For example, a global int i; at file scope and a local int i; inside a function f() are different variables; inside f, references to i refer to the local one (the global is shadowed). After f returns, the local is gone, and references to i elsewhere refer to the global.
    • Dynamic Scope (not in C): In dynamic scoping (not used by C, but by some older languages or hypothetical scenarios), a variable reference resolves to the most recent binding in the call stack. For instance, if dynamic scoping were in effect and a function g() uses a variable x not defined in g, it would look to the function that called g, and so on up the call chain for an x. In C, this doesn’t happen; if g doesn’t have x and no global x exists, it’s a compile error.
  • Lifetime (Static vs Automatic):
    • Static lifetime: Variables declared at global scope or with the static keyword inside functions have static storage duration – they exist for the entire program run. Their binding to memory occurs when the program starts (or when the module is loaded) and persists.
    • Automatic lifetime: Local variables (non-static) have automatic storage – memory is allocated at block entry and freed at block exit (stack behavior). They are bound to memory each time the block/function is executed.
  • Static vs Dynamic Binding of values: Typically refers to things like function calls – in OOP languages dynamic binding means virtual dispatch at runtime. In C, function calls are always statically bound (there’s no built-in virtual dispatch, you manually use function pointers for polymorphism).
  • Choosing Static or Dynamic Scoping (theoretical): A question might present a scenario in a pseudo-code where you can choose static or dynamic scoping and ask how a variable’s value would differ. For example: int i = 10; void f() { int i = 20; g(); } void g() { printf("%d", i); }
    • Under static scoping, g() sees the global i (10), because g’s definition doesn’t have a local i and the global is in scope.
    • Under dynamic scoping, g() is called from f where a local i=20 is in effect, so g would find that and print 20.
    • C uses static scope, so in C it would print 10 in this example.
  • Mutable vs Immutable Binding: In C, variables are mutable by default (except those declared const). Binding in this context can mean association of a name to storage. Once a local variable is allocated (bound to a stack location), its value can change, but it remains bound to that same memory until it goes out of scope.
  • Name Resolution: If you have nested blocks: int x = 5; void foo() { int x = 10; { int x = 15; printf("%d", x); } printf("%d", x); } This will print 15 then 10. The innermost x shadows the outer x within that inner block. When that block ends, the middle x (value 10) is visible again in foo. The global x (5) is shadowed entirely within foo by the local x.
  • Storage Binding: Static binding of storage means a variable uses a fixed location (globals, static locals). Dynamic binding of storage means allocated at runtime (stack or heap). C’s automatic (stack) variables are dynamically bound to fresh storage each call, but their name resolution is static.
  • Takeaway: In C, assume static (lexical) scoping and understand how variables shadow others. Global vs local: local wins inside its scope. If a function needs to access a global shadowed by a local, you can use the global by qualifying (in C you can’t qualify with module name like some languages; you’d have to rename or not shadow, or use an external pointer).
  • Example Exam Q: Given a program with a global and a local of the same name and a function call, what gets printed under static vs dynamic scope? – We addressed that scenario above. The key is: C is static scoped.

Note: These concise notes prioritize syntax, concepts, and common pitfalls needed to solve typical C programming questions. Review each section and practice tracing code by hand, as many exam problems involve dry-running code to find outputs or detect errors. Always remember to consider the C standards and common behaviors as described by authoritative sources like Kernighan & Ritchie (ebook – The C Programming Language Ritchie & kernighan -.doc) (ebook – The C Programming Language Ritchie & kernighan -.doc). Good luck with your exam preparation!

Published inAI GeneratedComputer ScienceDeep Research

Be First to Comment

Leave a Reply

Your email address will not be published. Required fields are marked *