← Control Flow

Select a question from the sidebar

12 questions in this topic

Question 1 / 12

How do if/else if/else chains work in C?

The if statement evaluates a condition (any expression). If the expression is non-zero (true), the body executes. else if provides additional conditions. else catches all remaining cases.

Key rules:

The condition can be any expression. Zero = false, non-zero = true.
Braces {} are optional for single statements but strongly recommended.
else binds to the nearest preceding unmatched if (dangling else problem).
Conditions are evaluated top-to-bottom; only the first true branch executes.
There is no elif keyword in C (unlike Python) -- it is else if (two keywords).

Pseudo Code

1. if (condition1) { ... }
2. else if (condition2) { ... }  // only checked if condition1 is false
3. else { ... }                  // runs if all conditions are false
4. Conditions evaluated top-to-bottom
5. Only the first matching branch executes
6. Zero = false, non-zero = true

Code

#include <stdio.h>

int main(void) {
    int score = 85;

    if (score >= 90) {
        printf("Grade: A\n");
    } else if (score >= 80) {
        printf("Grade: B\n"); /* This prints */
    } else if (score >= 70) {
        printf("Grade: C\n");
    } else {
        printf("Grade: F\n");
    }

    /* Any non-zero value is true */
    int x = 42;
    if (x) {
        printf("x is non-zero (truthy)\n"); /* Prints */
    }

    /* Common pattern: null check */
    int *ptr = NULL;
    if (ptr) {
        printf("ptr is valid\n");
    } else {
        printf("ptr is NULL\n"); /* Prints */
    }

    /* Single-statement if (braces recommended anyway) */
    if (score > 50)
        printf("Passed\n");

    return 0;
}

Grade: B
x is non-zero (truthy)
ptr is NULL
Passed

Key Points

•Any non-zero expression is true; zero is false
•Only the first matching branch executes
•Always use braces, even for single-statement bodies
•else binds to the nearest unmatched if
•Null pointers evaluate to false; non-null to true

Gotchas

•if (x = 5) is assignment (always true), not comparison -- use if (x == 5)
•Omitting braces can cause bugs when adding statements later (Apple's goto fail bug)
•The dangling else problem: else binds to the nearest if, not the one you might expect
•if (0.1 + 0.2 == 0.3) is false due to floating-point precision

if (cond) executes when cond is non-zero. else if chains additional checks. else is the default. Only the first true branch runs. Always use braces.

•Non-zero = true, zero = false
•Always use braces for safety

#include <stdio.h>
int main(void) {
    int x = 5;
    if (x > 10) {
        printf("big\n");
    } else if (x > 0) {
        printf("positive\n"); /* prints */
    } else {
        printf("non-positive\n");
    }
    return 0;
}

positive

if (x = 5) is assignment, not comparison

Question 2 / 12

How does the switch statement work and what is fall-through behavior?

The switch statement compares an integer expression against constant case labels and jumps to the matching one.

Fall-through: After executing a case, execution continues to the NEXT case unless break is encountered. This is a major source of bugs but can be used intentionally (e.g., multiple cases sharing code).

Rules:

The switch expression must be an integer type (char, int, enum, etc.). Not float, not string.
Case labels must be compile-time integer constants.
default handles unmatched values (optional but recommended).
Each case is a label (jump target), not a block -- variables declared in one case are visible in others (use braces to create a block).
Duplicate case values are a compile error.

Pseudo Code

1. switch (integer_expr) { case CONST: ... break; }
2. Without break: execution falls through to the next case
3. case labels must be integer constants
4. default: handles unmatched values
5. Intentional fall-through: group multiple cases
6. Use braces inside case to declare local variables

Code

#include <stdio.h>

int main(void) {
    int day = 3;

    /* Basic switch with break */
    switch (day) {
        case 1: printf("Monday\n"); break;
        case 2: printf("Tuesday\n"); break;
        case 3: printf("Wednesday\n"); break; /* This prints */
        case 4: printf("Thursday\n"); break;
        case 5: printf("Friday\n"); break;
        default: printf("Weekend\n"); break;
    }

    /* Fall-through bug (missing break) */
    int x = 1;
    switch (x) {
        case 1: printf("one ");
        case 2: printf("two ");
        case 3: printf("three\n");
    }
    /* Output: one two three (all three print!) */

    /* Intentional fall-through: grouping cases */
    char ch = 'A';
    switch (ch) {
        case 'a':
        case 'e':
        case 'i':
        case 'o':
        case 'u':
        case 'A':
        case 'E':
        case 'I':
        case 'O':
        case 'U':
            printf("%c is a vowel\n", ch);
            break;
        default:
            printf("%c is a consonant\n", ch);
            break;
    }

    /* Local variables in case need braces */
    switch (day) {
        case 3: {
            int temp = day * 10;
            printf("temp = %d\n", temp);
            break;
        }
        default:
            break;
    }

    return 0;
}

Wednesday
one two three
A is a vowel
temp = 30

Key Points

•Fall-through is the default: without break, execution continues to the next case
•Case labels must be compile-time integer constants
•switch only works with integer types (not floats or strings)
•Intentional fall-through groups multiple case values
•Use braces inside case to declare local variables

Gotchas

•Forgetting break causes fall-through -- the #1 switch bug
•Variables declared in one case (without braces) are in scope for all subsequent cases
•switch does not work with strings -- use if/else if with strcmp() instead
•case ranges (case 1 ... 5:) are a GCC extension, not standard C

switch jumps to a matching case label. Without break, execution falls through to the next case. Only integer types are allowed. default handles unmatched values. Use braces for local variables inside case.

•Without break, execution falls through
•Only integer types in switch

#include <stdio.h>
int main(void) {
    int x = 2;
    switch (x) {
        case 1: printf("one\n"); break;
        case 2: printf("two\n"); break; /* prints */
        default: printf("other\n"); break;
    }
    return 0;
}

two

Missing break is the most common switch bug

Question 3 / 12

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

C has three loop constructs:

for loop: Best when the number of iterations is known. Has init, condition, and update in one line.

for (init; condition; update) { body }

while loop: Best when the loop depends on a condition that may not be iteration-count based.

while (condition) { body }

do-while loop: The body executes at least once, then the condition is checked.

do { body } while (condition);

Key differences:

for and while check the condition BEFORE the body (may execute zero times).
do-while checks AFTER the body (always executes at least once).
for puts init/condition/update together for readability.
Any loop can be rewritten using the other two forms.

Pseudo Code

for (init; cond; update) { body }  // pre-test, known iterations
while (cond) { body }               // pre-test, condition-based
do { body } while (cond);            // post-test, at least once

for = while equivalent:
  init;
  while (cond) { body; update; }

do-while always executes body at least once

Code

#include <stdio.h>

int main(void) {
    /* for loop: known iterations */
    printf("for: ");
    for (int i = 0; i < 5; i++) {
        printf("%d ", i);
    }
    printf("\n"); /* 0 1 2 3 4 */

    /* while loop: condition-based */
    printf("while: ");
    int n = 1;
    while (n <= 16) {
        printf("%d ", n);
        n *= 2;
    }
    printf("\n"); /* 1 2 4 8 16 */

    /* do-while: executes at least once */
    printf("do-while: ");
    int x = 100;
    do {
        printf("%d ", x);
        x--;
    } while (x > 100); /* condition false immediately */
    printf("\n"); /* 100 (body ran once!) */

    /* do-while for input validation */
    int value;
    do {
        value = 42; /* simulate reading input */
    } while (value < 0);
    printf("valid: %d\n", value);

    /* while vs do-while: zero iterations */
    int count = 0;
    while (count > 0) {
        printf("never\n"); /* never executes */
    }

    return 0;
}

for: 0 1 2 3 4 
while: 1 2 4 8 16 
do-while: 100 
valid: 42

Key Points

•for: init/condition/update in one line, best for counted loops
•while: pre-test loop, may execute zero times
•do-while: post-test loop, always executes at least once
•for and while are equivalent in power; do-while guarantees one execution
•do-while is common for input validation and macro wrappers

Gotchas

•do-while requires a semicolon after while(cond); -- easy to forget
•for(;;) and while(1) both create infinite loops
•In C89, you cannot declare variables in for-loop init: int i in for(int i=0;...) requires C99+
•Modifying the loop variable inside the body of a for-loop can cause confusing behavior

for: known iterations, pre-test. while: condition-based, pre-test (0+ times). do-while: post-test, always runs at least once. do-while requires a trailing semicolon.

•for/while = pre-test; do-while = post-test
•do-while runs at least once

#include <stdio.h>
int main(void) {
    for (int i = 0; i < 3; i++) printf("%d ", i); /* 0 1 2 */
    printf("\n");
    int x = 10;
    do { printf("%d\n", x); } while (x < 0); /* prints 10 once */
    return 0;
}

0 1 2 
10

Forgetting the semicolon after do-while: do { } while(cond) <-- needs ; here

Question 4 / 12

How do break and continue work in loops?

break immediately exits the innermost enclosing loop or switch. Execution continues after the loop/switch.

continue skips the rest of the current iteration and jumps to the next iteration (the condition check in while/do-while, or the update expression in for).

Key rules:

Both only affect the innermost loop. To break out of nested loops, use a flag variable, goto, or refactor into a function with return.
break in a switch inside a loop only exits the switch, not the loop.
continue in a for-loop skips to the update expression (i++), then the condition check.
continue in a while-loop skips to the condition check directly.

Pseudo Code

break:    exit innermost loop/switch immediately
continue: skip rest of current iteration, go to next

In for(init;cond;update): continue goes to update, then cond
In while(cond): continue goes to cond
In do-while: continue goes to cond at bottom

Neither affects outer loops -- only the innermost

Code

#include <stdio.h>

int main(void) {
    /* break: exit loop early */
    printf("break: ");
    for (int i = 0; i < 10; i++) {
        if (i == 5) break;
        printf("%d ", i);
    }
    printf("\n"); /* 0 1 2 3 4 */

    /* continue: skip even numbers */
    printf("continue: ");
    for (int i = 0; i < 10; i++) {
        if (i % 2 == 0) continue;
        printf("%d ", i);
    }
    printf("\n"); /* 1 3 5 7 9 */

    /* continue in while -- be careful with counter */
    printf("while continue: ");
    int j = 0;
    while (j < 10) {
        j++;
        if (j % 2 == 0) continue;
        printf("%d ", j);
    }
    printf("\n"); /* 1 3 5 7 9 */

    /* break only exits innermost loop */
    for (int row = 0; row < 3; row++) {
        for (int col = 0; col < 3; col++) {
            if (col == 1) break; /* only breaks inner loop */
            printf("(%d,%d) ", row, col);
        }
    }
    printf("\n"); /* (0,0) (1,0) (2,0) */

    return 0;
}

break: 0 1 2 3 4 
continue: 1 3 5 7 9 
while continue: 1 3 5 7 9 
(0,0) (1,0) (2,0)

Key Points

•break exits the innermost loop or switch
•continue skips to the next iteration
•In for-loops, continue skips to the update expression, not past it
•Neither break nor continue affects outer loops
•break in a switch inside a loop only exits the switch

Gotchas

•continue in a while-loop can skip the counter increment, causing an infinite loop
•break inside a switch that is inside a loop only breaks the switch, not the loop
•There is no labeled break in C (unlike Java) -- use goto or a flag for nested loops
•Using too many break/continue makes code hard to follow -- consider refactoring

break exits the innermost loop/switch. continue skips to the next iteration. Neither affects outer loops. In for-loops, continue goes to the update expression.

•break = exit loop; continue = skip iteration
•Only affects the innermost loop

#include <stdio.h>
int main(void) {
    for (int i = 0; i < 10; i++) {
        if (i == 3) continue;  /* skip 3 */
        if (i == 7) break;     /* stop at 7 */
        printf("%d ", i);      /* 0 1 2 4 5 6 */
    }
    printf("\n");
    return 0;
}

0 1 2 4 5 6

continue in while can skip the counter update, causing infinite loop

Question 5 / 12

When is it appropriate to use goto in C?

goto transfers control to a labeled statement within the same function. While widely considered bad practice for general flow control, it has legitimate uses in C:

Legitimate uses:

Error handling / cleanup: Jumping to a cleanup section at the end of a function to release resources (the Linux kernel uses this extensively).
Breaking out of nested loops: C has no labeled break, so goto is the cleanest way.
Generated code: Machine-generated C code often uses goto.

Rules:

Labels have function scope (visible throughout the function).
Cannot jump into a different function.
Cannot jump over a variable declaration with an initializer (C99+).
Can only jump within the same function.

Pseudo Code

1. goto label;  // jump to label
2. label: statement;  // label definition
3. Legitimate: error cleanup, breaking nested loops
4. Avoid: spaghetti code, replacing structured loops
5. Cannot jump into another function or over VLA declarations

Code

#include <stdio.h>
#include <stdlib.h>

/* Pattern 1: Error cleanup (Linux kernel style) */
int process_data(const char *filename) {
    FILE *fp = NULL;
    char *buffer = NULL;
    int result = -1;

    fp = fopen(filename, "r");
    if (!fp) goto cleanup;

    buffer = malloc(1024);
    if (!buffer) goto cleanup;

    /* ... do work ... */
    result = 0; /* success */

cleanup:
    free(buffer);  /* free(NULL) is safe */
    if (fp) fclose(fp);
    return result;
}

/* Pattern 2: Breaking out of nested loops */
void find_value(int matrix[3][3], int target) {
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            if (matrix[i][j] == target) {
                printf("Found at (%d,%d)\n", i, j);
                goto done;  /* clean exit from both loops */
            }
        }
    }
    printf("Not found\n");
done:
    return;
}

int main(void) {
    int m[3][3] = {{1,2,3},{4,5,6},{7,8,9}};
    find_value(m, 5); /* Found at (1,1) */
    return 0;
}

Found at (1,1)

Key Points

•goto is acceptable for error cleanup and breaking nested loops
•The cleanup pattern is widely used in the Linux kernel
•Labels have function scope -- visible throughout the function
•goto can only jump within the same function
•Always jump forward (to cleanup at the end) for readability

Gotchas

•Jumping over variable initialization (C99+ with VLAs) is undefined behavior
•Spaghetti code: using goto for general flow control makes code unmaintainable
•goto cannot cross function boundaries -- use setjmp/longjmp for that (but avoid it too)
•Jumping into a loop or switch body from outside leads to confusing behavior

goto jumps to a label within the same function. Legitimate uses: error cleanup and breaking nested loops. The Linux kernel uses goto extensively for cleanup. Avoid for general flow control.

•Legitimate for cleanup and nested loop exit
•Only within the same function

#include <stdio.h>
#include <stdlib.h>
int init(void) {
    char *buf = malloc(100);
    if (!buf) goto fail;
    /* ... work ... */
    free(buf);
    return 0;
fail:
    return -1;
}
int main(void) {
    printf("%d\n", init());
    return 0;
}

Never jump over variable declarations with initializers

Question 6 / 12

How do nested loops work and what are common patterns?

Nested loops are loops inside loops. The inner loop completes all its iterations for each iteration of the outer loop.

Common patterns:

Matrix traversal: Row-by-row processing of 2D arrays.
Triangle patterns: Star/number triangles (common interview question).
Multiplication table: Two counters generating combinations.
Bubble sort: Outer loop for passes, inner for comparisons.

Performance: The total iterations are the product of all loop counts. A triply-nested loop over N elements is O(N^3).

Breaking out: break only exits the inner loop. Use goto, a flag, or refactor to a function for breaking all loops.

Pseudo Code

for (i = 0; i < rows; i++) {
    for (j = 0; j < cols; j++) {
        process(matrix[i][j]);
    }
}

Total iterations = outer_count * inner_count
break only exits the innermost loop

Code

#include <stdio.h>

int main(void) {
    /* 2D array traversal */
    int matrix[3][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            printf("%3d", matrix[i][j]);
        }
        printf("\n");
    }

    /* Right triangle pattern */
    printf("\nTriangle:\n");
    for (int i = 1; i <= 5; i++) {
        for (int j = 0; j < i; j++) {
            printf("* ");
        }
        printf("\n");
    }

    /* Multiplication table */
    printf("\nMultiplication table:\n");
    for (int i = 1; i <= 5; i++) {
        for (int j = 1; j <= 5; j++) {
            printf("%3d", i * j);
        }
        printf("\n");
    }

    /* Breaking nested loops with flag */
    int found = 0;
    for (int i = 0; i < 3 && !found; i++) {
        for (int j = 0; j < 4 && !found; j++) {
            if (matrix[i][j] == 7) {
                printf("\nFound 7 at [%d][%d]\n", i, j);
                found = 1;
            }
        }
    }

    return 0;
}

  1  2  3  4
  5  6  7  8
  9 10 11 12

Triangle:
* 
* * 
* * * 
* * * * 
* * * * * 

Multiplication table:
  1  2  3  4  5
  2  4  6  8 10
  3  6  9 12 15
  4  8 12 16 20
  5 10 15 20 25

Found 7 at [1][2]

Key Points

•Inner loop runs completely for each outer iteration
•Total iterations = product of all loop counts
•Row-major traversal (i then j) is cache-friendly for C arrays
•break only exits the innermost loop
•Use a flag variable or goto to break out of nested loops

Gotchas

•O(N^2) or O(N^3) nested loops can be very slow for large N
•Traversing matrix[j][i] (column-major) causes cache misses in C's row-major layout
•break inside the inner loop does NOT exit the outer loop
•Declaring the same variable name in both outer and inner loop is valid but confusing

Nested loops: inner loop completes fully for each outer iteration. Total iterations = product of loop counts. break only exits the inner loop. Row-major order (outer=row, inner=col) is cache-friendly.

•Inner loop runs fully per outer iteration
•break only exits innermost loop

#include <stdio.h>
int main(void) {
    for (int i = 1; i <= 4; i++) {
        for (int j = 0; j < i; j++) {
            printf("*");
        }
        printf("\n");
    }
    /* *
       **
       ***
       **** */
    return 0;
}

*
**
***
****

Column-major traversal of a 2D array is slow due to cache misses

Question 7 / 12

What is Duff's device?

Duff's device is a technique that interleaves a switch statement with a do-while loop to perform loop unrolling. It was invented by Tom Duff in 1983 to speed up memory-to-memory copies.

It exploits the fact that case labels in C are just jump targets and can appear inside loop bodies. This allows the first iteration to start partway through the unrolled loop body.

How it works:

Calculate how many extra iterations are needed before the unrolled loop can start (n % unroll_factor).
Use a switch to jump into the middle of the first loop iteration.
The do-while handles the remaining full groups of iterations.

Modern relevance:

Modern compilers perform loop unrolling automatically.
Duff's device is mostly a historical curiosity and interview question.
It demonstrates C's flexible switch/case semantics.

Pseudo Code

1. Calculate remainder: n % 8
2. Use switch(remainder) to jump into middle of loop
3. do-while handles full groups of 8
4. Each iteration processes 8 elements (unrolled)
5. First partial iteration handles the remainder

Code

#include <stdio.h>
#include <string.h>

/* Duff's device: copy n bytes from src to dst */
void duff_copy(char *dst, const char *src, int n) {
    if (n <= 0) return;
    int iterations = (n + 7) / 8;
    switch (n % 8) {
        case 0: do { *dst++ = *src++;
        case 7:      *dst++ = *src++;
        case 6:      *dst++ = *src++;
        case 5:      *dst++ = *src++;
        case 4:      *dst++ = *src++;
        case 3:      *dst++ = *src++;
        case 2:      *dst++ = *src++;
        case 1:      *dst++ = *src++;
                } while (--iterations > 0);
    }
}

int main(void) {
    const char *src = "Hello, Duff's device!";
    char dst[32] = {0};
    int len = (int)strlen(src) + 1;

    duff_copy(dst, src, len);
    printf("%s\n", dst); /* Hello, Duff's device! */

    return 0;
}

Hello, Duff's device!

Key Points

•Interleaves switch with do-while for manual loop unrolling
•Exploits C's fall-through: case labels are just jump targets
•Handles non-multiple-of-8 counts by starting mid-loop
•Modern compilers auto-unroll loops, making this mostly obsolete
•Demonstrates the power and danger of C's switch semantics

Gotchas

•This code is very hard to read and maintain -- avoid in production
•Modern compilers optimize loops better than manual unrolling in most cases
•Some compilers may generate worse code with Duff's device than a simple loop
•The technique only works because case labels are jump targets, not block boundaries

Duff's device interleaves a switch with a do-while loop for manual loop unrolling. It exploits C's fall-through behavior. Mostly a historical curiosity now -- modern compilers auto-optimize loops.

•Manual loop unrolling using switch fall-through
•Obsolete -- compilers do this automatically now

#include <stdio.h>
/* Simplified Duff's device: send n values */
void send(int *to, const int *from, int n) {
    int iterations = (n + 3) / 4;
    switch (n % 4) {
        case 0: do { *to++ = *from++;
        case 3:      *to++ = *from++;
        case 2:      *to++ = *from++;
        case 1:      *to++ = *from++;
                } while (--iterations > 0);
    }
}
int main(void) {
    int src[] = {1,2,3,4,5,6,7}, dst[7];
    send(dst, src, 7);
    for (int i = 0; i < 7; i++) printf("%d ", dst[i]);
    printf("\n");
    return 0;
}

1 2 3 4 5 6 7

Very hard to read; prefer compiler optimization flags instead

Question 8 / 12

How do you create infinite loops and when are they useful?

An infinite loop runs forever unless explicitly broken out of. Common forms:

while (1) { ... } -- most common in C.
for (;;) { ... } -- equivalent, some teams prefer this.
do { ... } while (1); -- less common.

Legitimate uses:

Event loops: GUI applications, servers waiting for connections.
Embedded systems: Main loop that runs forever (MCU firmware).
OS kernels: Scheduler loop.
Menu systems: Keep showing menu until user quits.
Read-process loops: Keep reading input until EOF.

Breaking out: Use break, return, or exit(). In signal-driven programs, use a volatile flag.

Pseudo Code

while (1) { ... break; }  // most common form
for (;;) { ... break; }    // equivalent
do { ... } while (1);      // less common

Break out with: break, return, exit(), or volatile flag

Code

#include <stdio.h>

int main(void) {
    /* Form 1: while(1) */
    int count = 0;
    while (1) {
        if (count >= 5) break;
        printf("tick %d\n", count++);
    }

    /* Form 2: for(;;) -- equivalent */
    count = 0;
    for (;;) {
        if (count >= 3) break;
        printf("tock %d\n", count++);
    }

    /* Practical: menu system */
    int choice = 0;
    int iterations = 0;
    while (1) {
        /* Simulate menu choice */
        choice = (iterations < 2) ? 1 : 3;
        switch (choice) {
            case 1: printf("Option 1\n"); break;
            case 2: printf("Option 2\n"); break;
            case 3: printf("Quit\n"); goto exit_menu;
        }
        iterations++;
    }
exit_menu:

    /* Embedded-style: event loop */
    /* while (1) {
        poll_sensors();
        process_data();
        update_outputs();
    } */

    return 0;
}

tick 0
tick 1
tick 2
tick 3
tick 4
tock 0
tock 1
tock 2
Option 1
Option 1
Quit

Key Points

•while(1) and for(;;) are the two standard forms
•Always have a clear exit condition (break, return, exit)
•Common in event loops, servers, embedded firmware, and menu systems
•for(;;) generates no compiler warnings about constant conditions
•Use volatile flag for signal-driven loop termination

Gotchas

•An infinite loop without side effects is undefined behavior in C11
•Forgetting the exit condition creates a hang, not a crash
•while(1) may generate a compiler warning about constant condition; for(;;) avoids this
•In multithreaded code, the loop variable must be volatile or atomic to prevent optimization

while(1) and for(;;) create infinite loops. Always include a break or return to exit. Used for event loops, servers, embedded systems, and menus. for(;;) avoids constant-condition warnings.

•while(1) and for(;;) are equivalent
•Always have an exit path

#include <stdio.h>
int main(void) {
    int i = 0;
    for (;;) {
        if (i >= 3) break;
        printf("%d\n", i++);
    }
    return 0;
}

0
1
2

Infinite loop without side effects is UB in C11

Question 9 / 12

How can loops be optimized in C?

Loop optimization techniques in C:

1. Minimize work inside the loop:

Move invariant calculations out of the loop (loop hoisting).
Pre-compute values used repeatedly.

2. Loop unrolling:

Process multiple elements per iteration to reduce loop overhead.
Modern compilers do this automatically with -O2/-O3.

3. Cache-friendly access:

Access arrays sequentially (stride-1) for good cache performance.
For 2D arrays: arr[i][j] in row-major order (i outer, j inner).

4. Reduce function calls:

Cache strlen() result: for(int i = 0, len = strlen(s); i < len; i++).
Avoid calling functions with the same arguments repeatedly.

5. Use appropriate types:

Loop counters as int or size_t, not short or char.
Use unsigned for counters that are always non-negative.

6. Let the compiler optimize:

Use -O2 or -O3 flags.
Avoid premature optimization -- profile first.

Pseudo Code

1. Hoist invariants: move constant computations out of loop
2. Cache function results: len = strlen(s) before loop
3. Access memory sequentially for cache hits
4. Use compiler optimization: -O2, -O3
5. Profile before optimizing: premature optimization is evil
6. Prefer int for loop counters (natural register size)

Code

#include <stdio.h>
#include <string.h>

int main(void) {
    /* BAD: strlen called every iteration -- O(n^2)! */
    char str[] = "hello world";
    /* for (int i = 0; i < strlen(str); i++) { ... } */

    /* GOOD: cache the length */
    int len = (int)strlen(str);
    for (int i = 0; i < len; i++) {
        str[i] = str[i]; /* placeholder operation */
    }

    /* BAD: invariant inside loop */
    /* for (int i = 0; i < n; i++) {
           result += arr[i] * (x * y + z);  // x*y+z is constant
       } */

    /* GOOD: hoist invariant */
    int arr[] = {1, 2, 3, 4, 5};
    int n = 5, x = 2, y = 3, z = 1;
    int factor = x * y + z;  /* compute once */
    int result = 0;
    for (int i = 0; i < n; i++) {
        result += arr[i] * factor;
    }
    printf("result = %d\n", result);

    /* Cache-friendly: row-major traversal */
    int matrix[100][100];
    /* GOOD: sequential memory access */
    for (int i = 0; i < 100; i++) {
        for (int j = 0; j < 100; j++) {
            matrix[i][j] = i + j;
        }
    }

    /* BAD: column-major causes cache misses */
    /* for (int j = 0; j < 100; j++)
           for (int i = 0; i < 100; i++)
               matrix[i][j] = i + j; */

    printf("matrix[50][50] = %d\n", matrix[50][50]);
    return 0;
}

result = 105
matrix[50][50] = 100

Key Points

•Cache strlen() result outside the loop
•Hoist loop-invariant computations
•Access arrays sequentially for cache locality
•Use compiler optimization flags (-O2, -O3) first
•Profile before micro-optimizing -- find the real bottleneck

Gotchas

•strlen() in a loop condition is O(n) per call, making the loop O(n^2)
•Column-major traversal of row-major arrays can be 10x slower due to cache misses
•Manual loop unrolling can make code slower if it defeats compiler auto-vectorization
•Premature optimization is the root of all evil (Knuth) -- always measure first

Key optimizations: cache strlen() before loop, hoist invariant computations, access arrays sequentially (row-major), and use -O2/-O3 compiler flags. Profile before optimizing.

•Cache function results outside loops
•Sequential memory access for cache performance

#include <stdio.h>
#include <string.h>
int main(void) {
    char s[] = "hello";
    /* BAD: for(int i=0; i<strlen(s); i++) -- O(n^2) */
    /* GOOD: */
    int len = (int)strlen(s);
    for (int i = 0; i < len; i++) {
        printf("%c", s[i]);
    }
    printf("\n");
    return 0;
}

hello

strlen() in loop condition makes it O(n^2)

Question 10 / 12

What is the dangling else problem?

The dangling else problem is an ambiguity that arises when an else clause could associate with more than one if statement.

Example:

if (a)
    if (b)
        printf("A");
else
    printf("B");

Question: Does the else belong to the outer if(a) or the inner if(b)?

C's rule: else binds to the nearest unmatched if. So it belongs to if(b). This means:

If a is false: nothing prints.
If a is true and b is true: prints "A".
If a is true and b is false: prints "B".

Solution: Always use braces to make the intent clear. The ambiguity disappears with explicit blocks.

Pseudo Code

Without braces:
  if (a)
    if (b) stmt1;
  else stmt2;        // else binds to inner if(b)

With braces (intent 1: else with inner if):
  if (a) {
    if (b) stmt1;
    else stmt2;
  }

With braces (intent 2: else with outer if):
  if (a) {
    if (b) stmt1;
  } else {
    stmt2;
  }

Code

#include <stdio.h>

int main(void) {
    int a = 1, b = 0;

    /* Dangling else: else binds to nearest if (if(b)) */
    printf("Dangling: ");
    if (a)
        if (b)
            printf("both true");
    else
        printf("b is false");  /* This prints (else binds to if(b)) */
    printf("\n");

    /* Clear intent 1: else with inner if */
    printf("Intent 1: ");
    if (a) {
        if (b) {
            printf("both true");
        } else {
            printf("a true, b false"); /* This prints */
        }
    }
    printf("\n");

    /* Clear intent 2: else with outer if */
    a = 0;
    printf("Intent 2: ");
    if (a) {
        if (b) {
            printf("both true");
        }
    } else {
        printf("a is false"); /* This prints */
    }
    printf("\n");

    return 0;
}

Dangling: b is false
Intent 1: a true, b false
Intent 2: a is false

Key Points

•else binds to the nearest unmatched if
•Indentation does NOT affect which if the else belongs to
•Always use braces to make intent explicit
•The dangling else is a classic source of logic bugs
•Most style guides require braces for all if/else bodies

Gotchas

•Misleading indentation can make dangling else look correct when it is wrong
•Without braces, adding a second statement to an if body creates a different bug
•The compiler follows syntax rules, not indentation
•Python avoids this with mandatory indentation; C does not

When else could match multiple if statements, it binds to the nearest unmatched if. This can be misleading if indentation suggests otherwise. Always use braces to make the binding explicit.

•else binds to nearest unmatched if
•Braces eliminate ambiguity

#include <stdio.h>
int main(void) {
    int a = 1, b = 0;
    /* else binds to if(b), not if(a) */
    if (a) {
        if (b) {
            printf("both\n");
        }
    } else {
        printf("a false\n"); /* clear intent with braces */
    }
    return 0;
}

Indentation does not affect parsing in C

Question 11 / 12

How does switch work with enum types?

Using switch with enum is a powerful pattern in C. Enums provide named constants, and the compiler can warn about unhandled enum values in a switch.

Benefits:

Self-documenting code: case STATE_INIT: instead of case 0:.
Compiler warnings: If you enable -Wswitch, the compiler warns about missing enum values.
Type safety: enum makes the intent clearer than magic numbers.

Best practice:

Do NOT add a default case when switching on an enum -- this allows the compiler to warn about missing cases.
If you must have a default, put an assertion to catch unexpected values.
Always handle all enum values.

Limitation: In C, enum is just int under the hood. You can assign any integer to an enum variable, and the compiler will not complain. This is different from C++ enum class.

Pseudo Code

1. Define enum with named states/values
2. switch(enum_var) with case for each enum value
3. Omit default to let compiler warn about missing cases
4. Enable -Wswitch or -Wall for warnings
5. enum values are just ints in C -- no type safety guarantee

Code

#include <stdio.h>

typedef enum {
    COLOR_RED,
    COLOR_GREEN,
    COLOR_BLUE,
    COLOR_YELLOW
} Color;

const char *color_name(Color c) {
    switch (c) {
        case COLOR_RED:    return "Red";
        case COLOR_GREEN:  return "Green";
        case COLOR_BLUE:   return "Blue";
        case COLOR_YELLOW: return "Yellow";
        /* No default: compiler warns if we add a new color
           and forget to handle it here (-Wswitch) */
    }
    return "Unknown"; /* fallback for invalid values */
}

/* State machine pattern */
typedef enum {
    STATE_INIT,
    STATE_RUNNING,
    STATE_DONE
} State;

void run_machine(void) {
    State s = STATE_INIT;
    int steps = 0;
    while (s != STATE_DONE) {
        switch (s) {
            case STATE_INIT:
                printf("Initializing...\n");
                s = STATE_RUNNING;
                break;
            case STATE_RUNNING:
                printf("Running step %d\n", steps++);
                if (steps >= 3) s = STATE_DONE;
                break;
            case STATE_DONE:
                break;
        }
    }
    printf("Done!\n");
}

int main(void) {
    printf("%s\n", color_name(COLOR_BLUE)); /* Blue */
    run_machine();
    return 0;
}

Blue
Initializing...
Running step 0
Running step 1
Running step 2
Done!

Key Points

•enum + switch is self-documenting and maintainable
•Omit default to get compiler warnings about unhandled enum values
•State machine pattern: enum for states, switch for transitions
•Enable -Wswitch (included in -Wall) for missing case warnings
•enum values are named constants that make code readable

Gotchas

•Adding default suppresses the -Wswitch warning about missing enum values
•In C, enum is just int -- you can assign any integer, bypassing the enum values
•Enum values without explicit assignment start at 0 and increment by 1
•If you cast an arbitrary int to enum and switch on it, unhandled values fall through silently

Switch on enum gives self-documenting code and compiler warnings for missing cases (with -Wswitch). Omit default to let the compiler catch missing cases. Enum values are just ints in C.

•Omit default for compiler warnings on missing cases
•enum + switch is ideal for state machines

#include <stdio.h>
typedef enum { RED, GREEN, BLUE } Color;
const char *name(Color c) {
    switch (c) {
        case RED:   return "Red";
        case GREEN: return "Green";
        case BLUE:  return "Blue";
    }
    return "Unknown";
}
int main(void) {
    printf("%s\n", name(GREEN)); /* Green */
    return 0;
}

Green

default suppresses -Wswitch warnings about missing enum values

Question 12 / 12

How do you implement a simple state machine using switch in C?

A state machine has a finite set of states, transitions between states based on input/events, and actions performed during transitions.

Implementation pattern:

Define states as an enum.
Use a switch statement to handle each state.
Each case processes the current state and sets the next state.
Wrap in a loop that runs until a terminal state is reached.

This is one of the most common and useful patterns in C programming, used in parsers, network protocols, embedded controllers, and game logic.

Advantages:

Clear, readable structure.
Easy to add new states.
Compiler can warn about unhandled states (if no default).
Each state's logic is isolated in its case block.

Pseudo Code

1. enum State { START, PROCESSING, ERROR, DONE };
2. State current = START;
3. while (current != DONE) {
4.   switch (current) {
5.     case START:      ... current = PROCESSING; break;
6.     case PROCESSING: ... current = DONE; break;
7.     case ERROR:      ... current = DONE; break;
8.   }
9. }

Code

#include <stdio.h>
#include <ctype.h>
#include <string.h>

/* Simple integer parser state machine */
typedef enum {
    PARSE_START,
    PARSE_SIGN,
    PARSE_DIGITS,
    PARSE_DONE,
    PARSE_ERROR
} ParseState;

int parse_int(const char *str, int *result) {
    ParseState state = PARSE_START;
    int sign = 1;
    int value = 0;
    int i = 0;
    int len = (int)strlen(str);

    while (state != PARSE_DONE && state != PARSE_ERROR) {
        char ch = (i < len) ? str[i] : '\0';

        switch (state) {
            case PARSE_START:
                if (ch == '+' || ch == '-') {
                    sign = (ch == '-') ? -1 : 1;
                    state = PARSE_SIGN;
                    i++;
                } else if (isdigit(ch)) {
                    state = PARSE_DIGITS;
                } else {
                    state = PARSE_ERROR;
                }
                break;

            case PARSE_SIGN:
                if (isdigit(ch)) {
                    state = PARSE_DIGITS;
                } else {
                    state = PARSE_ERROR;
                }
                break;

            case PARSE_DIGITS:
                if (isdigit(ch)) {
                    value = value * 10 + (ch - '0');
                    i++;
                } else if (ch == '\0') {
                    state = PARSE_DONE;
                } else {
                    state = PARSE_ERROR;
                }
                break;

            case PARSE_DONE:
            case PARSE_ERROR:
                break;
        }
    }

    if (state == PARSE_DONE) {
        *result = sign * value;
        return 1; /* success */
    }
    return 0; /* error */
}

int main(void) {
    int val;
    if (parse_int("-42", &val)) {
        printf("Parsed: %d\n", val); /* -42 */
    }
    if (parse_int("123", &val)) {
        printf("Parsed: %d\n", val); /* 123 */
    }
    if (!parse_int("12abc", &val)) {
        printf("Parse error\n"); /* error */
    }
    return 0;
}

Parsed: -42
Parsed: 123
Parse error

Key Points

•Enum for states, switch for transitions, loop until terminal state
•Each state handles its own input and decides the next state
•Clean separation of concerns: one case per state
•Used everywhere: parsers, protocols, embedded controllers, games
•Compiler warns about unhandled states if no default case

Gotchas

•Forgetting break causes unintended fall-through between states
•State machines can grow large -- consider function pointers for complex cases
•Always handle the terminal/error states to avoid infinite loops
•Without a default case, adding a new enum value will trigger -Wswitch if unhandled

Define states as enum, switch on current state in a loop, each case sets the next state. Break when terminal state is reached. This pattern is used in parsers, protocols, and embedded systems.

•Enum + switch + loop = state machine
•Each case handles one state and sets the next

#include <stdio.h>
typedef enum { START, RUNNING, DONE } State;
int main(void) {
    State s = START;
    int n = 0;
    while (s != DONE) {
        switch (s) {
            case START:   printf("Init\n"); s = RUNNING; break;
            case RUNNING: printf("Step %d\n", n++);
                          if (n >= 3) s = DONE; break;
            case DONE:    break;
        }
    }
    printf("Done\n");
    return 0;
}

Init
Step 0
Step 1
Step 2
Done

Forgetting break causes fall-through between states

Built by onllm.dev

Home GitHub Support awesomePrep