Lesson 05: Branches

if (condition) {
// Statements inside the body of 'if', will be executed if the condition is true
}

If the condition is evaluated as true, the statements inside the body of if are executed. Otherwise, the statements inside the body of if are skipped.

if (condition) {
// Statements inside the body of 'if', will be executed if the condition is true
} else {
// Statements inside the body of 'else', will be executed if the condition is false
}

If the condition is evaluated as true, the statements inside the body of if are executed. Otherwise, the statements inside the body of else are executed.

The simple way to make a decision in C/C++ is with the if statement. Here is an example of an if statement at work

// if it is Feb 28 and it is a leap year
if ((day == 28) && (month == 2) && (year % 4 == 0) && (year % 100 != 0)) {
    day = 29;       // then the next day is 29th
} else {            // otherwise
    day = 1;        // next day is March 1st
    month = 3;
}

When an if-else statement is present inside the body of another if or/and else, this is called nested if-else.

if (condition1) {
// Nested if-else inside the body of "if"
if (condition2) {
// Statements inside the body of nested "if"
} else {
// Statements inside the body of nested "else"
}
} else {
// Statements inside the body of "else"
}

if (condition1) {
// Statements inside the body of "if"
} else {
// Nested if-else inside the body of "else"
if (condition2) {
// Statements inside the body of nested "if"
} else {
// Statements inside the body of nested "else"
}
}

The else-if ladder statement is useful when checking multiple conditions within the program; nesting of if-else blocks can be avoided using the else-if ladder statement.

if (condition1) {
// These statements would execute if the condition1 is true
} else if (condition2) {
// These statements would execute if the condition2 is true
} else if (condition3) {
// These statements would execute if the condition3 is true
} …

} else {
// These statements will execute if all the conditions return false
}

The switch statement is C/C++'s multiway branch statement. It is used to route execution in one of several different ways. In fact, the switch statement is a special else-if ladder statement in which the conditions are used to compare the same expression with different values. The general form of the statement is:

switch (expression){
case constant1:
// Statements sequence 1
break;
case constant2:
// Statements sequence 2
break;
•
•
•
case constantN:
// Statements sequence N
break;
default:
// Default statements
}

Each statement sequence may be from one to several statements long. The default portion is optional. Both the expression and the case constants must be integer types.

The switch works by checking the expression against the constants.

• If a match is found, that sequence of statements is executed.
• If the statement sequence associated with the matching case does not contain a break, execution will continue on into the next case. Put differently, from the point of the match, execution will continue until either a break statement is found or the switch ends.
• If no match is found and a default case is existent, its statement sequence is executed. Otherwise, no action takes place.

#include 
int main()
{
    int arr[] = { 1, 5, 15, 20 };

    for (int i = 0; i < 4; i++)
    {
        switch (arr[i])
        {
        case 1 ... 6:
            printf("%d in range 1 to 6\n", arr[i]);
            break;
        case 19 ... 20:
            printf("%d in range 19 to 20\n", arr[i]);
            break;
        default:
            printf("%d not in range\n", arr[i]);
            break;
        }
    }
    return 0;
}

The marks obtained by a student in 5 different subjects are input through the keyboard. The students get a division as per the following rules:

• Percentage above or equal to 60 - First Division
• Percentage between 50 and 59 - Second Division
• Percentage between 40 and 49 -Third Division
• Percentage less than 40 - Fail

#include <stdio.h>
#include <conio.h>

int main()
{
    int eng,math,com,sci,ss,total;
    float per;

    printf("Enter Five Subjects Marks\n");
    scanf("%d%d%d%d%d",&eng,&math,&com,&sci,&ss);

    total = eng + math + com + sci + ss ;
    printf("Toal Marks : %d",total);
    per = total * 100.00 / 500;
    printf("\n Percentage : %f", per);

    if (per >= 60)
        printf("1st Division \r\n");
    if (per >= 50 && per <= 59)
        printf("2nd Division \r\n");
    if (per >= 40 && per <= 49)
        printf("3rd Division \r\n");
    if (per < 40)
        printf("Sorry Fail! \r\n");

    return 0;
}

#include <stdio.h>
#include <conio.h>

int main()
{
    int eng,math,com,sci,ss,total;
    float per;

    printf("Enter Five Subjects Marks\n");
    scanf("%d%d%d%d%d",&eng,&math,&com,&sci,&ss);

    total = eng + math + com + sci + ss ;
    printf("Toal Marks : %d",total);
    per = total * 100.00 / 500;
    printf("\n Percentage : %f", per);

    if(per >= 60) {
        printf("\n 1st Division");
    } else if(per >= 50) {
        printf("\n 2nd Division");
    } else if(per >= 40) {
        printf("\n 3rd Division");
    } else {
        printf("\n Sorry Fail");
    }

    return 0;
}

#include <stdio.h>
#include <conio.h>

int main()
{
    int eng,math,com,sci,ss,total;
    float per;

    printf("Enter Five Subjects Marks\n");
    scanf("%d%d%d%d%d",&eng,&math,&com,&sci,&ss);

    total = eng + math + com + sci + ss ;
    printf("Toal Marks : %d",total);
    per = total * 100.00 / 500;
    printf("\n Percentage : %f", per);

    switch ( (int) per) {
        case 60 ... 100:
            printf("\n 1st Division");
            break;
        case 50 ... 59:
            printf("\n 2nd Division");
            break;
        case 40 ... 49:
            printf("\n 3rd Division");
            break;
        dfault:
            printf("\n Sorry Fail");
    }

    return 0;
}

The break is used to exit from a do, for, or while loop, bypassing the normal loop condition, as shown in Figure 2.1. It is also used to exit from a switch statement.

Figure 2.1: Operation of the break Statement

The break statement is often used to handle unexpected or nonstandard situations that arise within a loop. An example of a break in a loop is shown below:

do {
    x = getx();
    if ( x < 0 ) break;    // terminate if negative
    process(x);
} while (!done);

Here, if x is negative, the loop is terminated.

In a switch statement, the break keeps program execution from "falling through" to the next case. (Refer to the switch statement for details.)

The continue statement is similar to the break statement in that it is usually activated by an unexpected condition in a loop. However, it returns control to the top of the loop — causing the loop to continue — rather than causing an exit from the loop. Figure 2.2 shows how this looks.

Figure 2.2: Operation of the continue Statement

Whereas the break statement causes an exit from a loop, the continue statement causes part of the loop to be "short-circuited" or bypassed while the loop keeps running. That is, following a continue, control goes back to the top of the loop. For example, the following while loop reads characters from the keyboard until an s is typed:

while (ch = getchar()) {
    if (ch != 's')
        continue;    // read another char
    process(ch);
}

The call to process() will not occur until ch contains the character s.

do {
    cout << "Enter dividend: ";
    cin >> dividend;
    cout << "Enter divisor: ";
    cin >> divisor;

    if (divisor == 0) {         // if user error,
        cout << "Divisor cannot be zero." << endl;
        continue;               // go back to top of loop
    }
    cout << "Quotient is " << dividend / divisor << endl;
    cout << "Do another (y/n)? ";
    cin >> ch;
} while ((ch != 'n') && (ch != 'N'));

In C++, the goto statement is a control flow statement that transfers the program execution to a specific labeled statement. It is generally considered harmful in modern programming practices and is discouraged due to its ability to create spaghetti code. However, there are certain scenarios where the usage of the goto statement might be appropriate.

Basic Structure of a goto Statement:

The goto statement consists of the keyword goto followed by the label of the destination statement. The destination label is preceded by a colon (:).

The goto keyword causes program execution to jump to the label specified in the goto statement. The general form of goto is:

    goto    label;
label:

All labels must end in a colon (:) and must not conflict with keywords or function names. Furthermore, a goto can branch only within the current function — not from one function to another.

Example of a goto Statement:

Consider a program that checks the age of a user and displays a message based on the age:

    int age;
    cin >> age;

    if (age < 18) {
        goto underage;  // Transfer execution to the "underage" label
    }
    cout << "Welcome to the program!" << endl;
label:                  // Label for the "label" statement
    cout << "Invalid age entered." << endl;
    return;

underage:              // Label for the "underage" label
    cout << "You must be 18 or older to enter." << endl;
    return;

In this example, the goto statement is used to transfer execution to the appropriate label based on the user's age.

Reasons to Avoid the goto Statement:

The goto statement is generally discouraged due to several reasons:

• Readability: Excessive use of goto statements can make code difficult to read and understand, leading to spaghetti code.
• Maintainability: Code with goto statements is often harder to maintain and modify as the logic of the program becomes intertwined and less structured.
• Alternative Control Flow Statements: C++ provides more structured control flow statements, such as if-else, switch-case, and loops, which are generally preferred over goto for better readability and maintainability.
• Debugging Difficulty: Debugging code with goto statements can be challenging as the flow of execution can become unpredictable.

Alternatives to the goto Statement:

In most cases, the goto statement can be replaced with more structured control flow statements, such as if-else, switch-case, and loops. These statements provide a more organized and maintainable approach to controlling program execution.

Appropriate Use Cases for goto:

While the goto statement is generally discouraged, there are a few rare instances where its usage might be appropriate:

1. Error Handling: In certain error handling scenarios, the goto statement can be used to jump out of nested loops or complex control flow structures.
2. Emulating Break and Continue Statements: In situations where you need to break out of multiple loops or skip iterations, the goto statement can be used in combination with labeled statements to achieve similar functionality.

The goto statement is a powerful tool in C++, but its usage should be carefully considered and used sparingly. In most cases, more structured control flow statements are preferred for better readability, maintainability, and debugging ease. When using the goto statement, it is crucial to document its purpose clearly and ensure that it does not lead to spaghetti code.

The return statement is a control flow statement that terminates the execution of the current function and optionally returns a value to the caller. It is a crucial component of function implementation, allowing functions to communicate results back to the code that invoked them.

Syntax of the return Statement:

The return statement forces a return from a function and can be used to transfer one value back to the calling routine. It has these two forms:

In C99 and C++, the form of return that does not specify a value must be used only in void functions.

Keep in mind that as soon as a return is encountered, the function will return, skipping any other code that may be in the function.

Also, a function can contain more than one return statemenst.

Purpose of the return Statement:

The return statement serves several important purposes in C++ programming:

1. Function Termination: It explicitly ends the execution of the current function, causing the program to exit the function's scope and return to the caller's context.
2. Value Passing: It allows functions to communicate results back to the code that invoked them. The returned value can be used in the caller's scope for further processing or decision-making.
3. Early Termination: It enables functions to exit prematurely, skipping the remaining code in the function and returning it to the caller. This can be useful for handling error conditions or specific return scenarios.

Types of return Statements:

There are two main types of return statements in C++:

1. Void Return: The return statement doesn't require an expression when a function's return type is void. It simply terminates the function's execution without returning a value.
   

   void printHello() {
       cout << "Hello, world!" << endl;
       return; // Function terminates without returning a value
   }

2. Value Return: When a function has a non-void return type, the return statement must include an expression that determines the value to be returned. The returned value must be compatible with the function's return type.
   

   int addNumbers(int x, int y) {
       return x + y; // Function returns the sum of x and y
   }

In conclusion, the return statement is a fundamental element of C++ programming, enabling functions to communicate results, terminate execution, and facilitate structured program flow. Its proper usage ensures clear and maintainable code, allowing programmers to create well-defined and modular functions.