CONTROL FLOW & DECISION MAKING

Once you know the building blocks of C (Unit 1), the next step is to master the flow of execution. Control Flow Statements are the engine of every program, allowing it to make decisions, repeat actions, and process large amounts of data efficiently.

Decision Making Statements

Decision-making statements (or conditional statements) allow your program to choose which block of code to execute based on whether a condition is true or false.

A. The `if` Family (The Workhorse)

The if statement is the most fundamental control structure.

if Statement: Executes a block of code only if the condition evaluates to true.
if-else Statement: Executes the if block if the condition is true, and the else block if it is false.
else-if Ladder: Used to check multiple conditions sequentially. Once a condition is found to be true, the corresponding block is executed, and the rest of the ladder is skipped. This is highly efficient.
nested if: Placing an entire if statement inside another if or else block.

Expert Insight: The Dangling Else Problem

When you use nested if statements without braces, C can get confused. An else clause always associates with the nearest preceding unmatched if.

Best Practice: Always use curly braces {} with every if and else block, even for single statements, to avoid ambiguity and improve code readability.

B. The `switch` Statement (The Cleaner Alternative)

The switch statement is a powerful, cleaner alternative to a long else-if ladder when you are comparing a single variable against multiple constant values.

How it Works: The value of an expression is checked against various case labels. When a match is found, execution begins from that case.
The Crucial Rule: After a match, execution continues to the next case unless a break statement is encountered. The default block executes if no case matches.

Important Rule Reminder: The switch expression and case labels can only be of type integer (int) or character (char). They cannot be floating-point numbers (float, double) or ranges.

switch (day) {

case 1:

printf("Monday");

break; // Stops execution inside the switch

case 7:

printf("Sunday");

break;

default:

printf("Weekday");

}

Looping Statements (Repetitive Control)

Loops allow a block of code to be executed repeatedly until a specified condition is met.

The `for` Loop

The for loop is the most compact loop structure and is ideal when you know the exact number of iterations needed.

Part	Description
Initialization	Executed once before the loop starts (e.g., `i = 1`).
Condition	Checked before every iteration. If true, the loop body executes.
Updation	Executed after every loop iteration (e.g., `i++`).

The `while` Loop (Entry-Controlled)

The while loop is an Entry-Controlled Loop. The condition is checked at the beginning. If the condition is false initially, the loop body will never execute. It is best used when the number of iterations is unknown and depends on a dynamic condition.

The `do-while` Loop (Exit-Controlled)

The do-while loop is an Exit-Controlled Loop. The condition is checked at the end of the loop. This structure guarantees that the loop body will execute at least once, regardless of whether the condition is initially true or false.

Expert Insight: Infinite Loops

An infinite loop executes forever. While dangerous in typical applications, they are standard and necessary in embedded systems (like an Arduino or washing machine firmware) or operating system kernels, where the program is designed to run continuously.

Standard C syntax for infinite loops: while(1) or for(;;)

Expert Insight: Infinite Loops

Standard C syntax for infinite loops: while(1) or for(;;)

Jump Statements

These statements alter the normal, sequential flow of execution within loops.

break: Used inside loops and switch statements. It forces the immediate termination of the current loop (or switch) and program control resumes at the statement immediately following the loop.
continue: Used only inside loops. It skips the rest of the current iteration of the loop and forces the control to immediately proceed to the next iteration (checking the condition again).

Pattern Printing Logic (Nested Loops in Action)

Printing patterns (stars, numbers, characters) is a classic introductory exercise that forces you to master nested loops.

Outer Loop: Always controls the number of rows (the vertical count).
Inner Loop: Always controls the elements within each row (the horizontal count), such as spaces or the actual pattern characters.

Advanced Concept: Short-Circuit Evaluation

This is a crucial concept for writing robust, error-free code, especially when using Logical Operators (&& AND and || OR).

Operator	Behavior (Short-Circuit)
`&&` (AND)	If the first expression is false, the overall result must be false. Therefore, the second expression is not evaluated.
**`

// Prevents a crash if 'ptr' is NULL

if (ptr != NULL && ptr->value > 10) {

// ...

}

If ptr is NULL, the first condition (ptr != NULL) is false. C immediately "short-circuits" and never evaluates the second part (ptr->value > 10), thus preventing a potentially fatal NULL pointer access error.

Deep Dive: Logical AND (`&&`) vs. Bitwise AND (`&`)

While both operators use the word "AND," they operate on completely different levels and yield different types of results. Understanding this is key to debugging conditional logic and low-level operations.

Feature	Logical AND (&&)	Bitwise AND (&)
Purpose	Used in conditional expressions (like `if` statements) to check if two conditions are simultaneously true.	Used to perform low-level manipulation on the individual bits of integer data.
Operates On	Boolean Values (true/false, where any non-zero value is true, and zero is false).	Individual Bits (0 or 1) of the operands.
Result Type	Boolean (returns `1` for true, or `0` for false).	Integer (returns a new number).
Short-Circuit?	Yes. If the first operand is false, the second is never evaluated (critical for safety).	No. Both operands are always fully evaluated before the operation is performed.

A. Logical AND (`&&`) Example

The && operator checks for the truth value of entire expressions.

int x = 5, y = 10;

// The expression (x > 0) is TRUE (1)

// The expression (y < 5) is FALSE (0)

if ( (x > 0) && (y < 5) ) {

// This block is NOT executed because TRUE && FALSE = FALSE (0)

}

B. Bitwise AND (`&`) Example

The & operator works on the binary representation of the numbers, comparing them bit by bit.

Let $A = 5$ and $B = 3$ .

Decimal: $A = 5$ , $B = 3$
Binary: $A = 0101_2$ , $B = 0011_2$

Bit Position	A (5)	B (3)	A & B
4th	0	0	0
3rd	1	0	0
2nd	0	1	0
1st	1	1	1

he result of $A \text{ \& } B$ is $0001_2$ , which is 1 in decimal.

Key Use Case: Bitwise AND is often used for masking, which means checking if a specific bit (or group of bits) in a number is set to 1.

Elaborated Expert Insights for Control Flow

A. Short-Circuit Evaluation: The Safety Guard

Short-circuit evaluation applies only to the Logical AND (&&) and Logical OR (||) operators. It is a critical feature that affects both performance and safety in your code.

How It Works

Logical AND (&&): If the first operand evaluates to false (0), the result of the entire expression must be false. The C compiler skips evaluating the second operand.
Logical OR (||): If the first operand evaluates to true (non-zero), the result of the entire expression must be true. The C compiler skips evaluating the second operand.

Practical Application (Error Prevention)

The primary use is to prevent runtime errors by conditionally checking for error conditions before performing an operation that could crash the program.

int denom = 0;

if (denom != 0 && num / denom > 5) {

// Safe: If denom is 0, the second part (num / denom) is skipped.

}

struct Node *ptr = NULL;

// ...

if (ptr != NULL && ptr->data > 10) {

// Safe: If ptr is NULL, the check (ptr->data > 10) is skipped,

// preventing a segmentation fault.

}

B. The Dangling Else Problem: Code Ambiguity

The "Dangling Else" problem arises only in nested if statements where an else is present without the use of curly braces.

The Ambiguity

Consider this piece of code:

if (A)

if (B)

statement_1;

else

statement_2;

int denom = 0;
if (denom != 0 && num / denom > 5) {
    // Safe: If denom is 0, the second part (num / denom) is skipped.
}

Preventing NULL Pointer Dereference:

struct Node *ptr = NULL;
// ...
if (ptr != NULL && ptr->data > 10) {
    // Safe: If ptr is NULL, the check (ptr->data > 10) is skipped, 
    // preventing a segmentation fault.
}

B. The Dangling Else Problem: Code Ambiguity

The "Dangling Else" problem arises only in nested if statements where an else is present without the use of curly braces.

The Ambiguity

Consider this piece of code:

if (A)
    if (B)
        statement_1;
else
    statement_2;

A human reader could interpret this in two ways:

Interpretation 1 (Outer if): statement_2 runs if A is false.
Interpretation 2 (Inner if): statement_2 runs if A is true and B is false.

C's Resolution Rule

C, along with many other languages (Java, C++), resolves this ambiguity by using the Nearest Match Rule:

An else always binds (or pairs) with the nearest preceding unmatched if statement in the same block.

In the example above, C chooses Interpretation 2. The else is matched to the inner if (B).

Solution: Use Braces!

To force the structure you intended (e.g., to match the else with the outer if), you must use curly braces {} to explicitly define the scope:

// Forces 'else' to match the outer 'if (A)'

if (A) {

if (B)

statement_1;

} else {

statement_2;

}

Best Practice: Always use braces around the bodies of if and else blocks to guarantee clarity and prevent this problem.

C. Pattern Printing Logic: Mastering Nested Loops

Pattern printing is more than just a coding exercise; it is the fundamental way students master the coordination of nested loops. This logic is essential for tasks far beyond printing stars.

Loop	Purpose	Control Variable
Outer Loop	Controls the ROWS (vertical movement/number of lines).	Typically `i`
Inner Loop	Controls the COLUMNS (horizontal content/what is printed on a line).	Typically `j`
Logic Link	The Inner Loop's condition is usually dependent on the Outer Loop's variable (`j <= i`).	The length of the row changes with the row number.

Real-World Application of Nested Loop Logic

The concept of iterating over rows and columns is used in:

2D Arrays/Matrices: Performing matrix operations (addition, multiplication) requires two or three nested loops.
Sorting Algorithms: Bubble Sort and Selection Sort use nested loops to compare and swap elements repeatedly.
Grid-based Games: Handling movement or processing tiles on a game board (like Chess or Tic-Tac-Toe).

D. Switch vs. If-Else: Performance and Readability

While beginners often focus on which is faster, the choice is usually about readability and appropriate use.

Compiler Optimization: For a switch statement with many constant integer cases, the C compiler can often generate a jump table. This allows the program to jump directly to the correct case in constant time ( $O(1)$ ), which is generally faster than the sequential comparisons of a long if-else ladder ( $O(n)$ ).
Readability: For checking a single variable against many discrete constants (e.g., menu choices, day numbers), switch is far cleaner and more expressive.
Flexibility: For checking ranges, floating-point values, or complex logical expressions (e.g., age > 18 && balance < 500), the if-else ladder is the only correct choice.

CONTROL FLOW & DECISION MAKING