11. Flow control structures: decision

Página 11

Flow control structures are fundamental aspects in any logic programming course, as they allow the creation of programs that can make decisions, that is, perform different actions depending on the circumstances. They are divided into three main types: sequential, decision, and repeat. In this chapter, we will focus on decision structures.

Decision structures, also known as conditional structures, are used to decide which block of code should be executed based on a condition. This condition is an expression that can evaluate to true or false. If the condition is true, a block of code is executed. If false, another block of code is executed.

The simplest example of a decision structure is the 'if' statement. The 'if' statement evaluates a condition and, if the condition is true, executes a block of code. Here is an example of what this might look like in pseudocode:

  if (condition) {
    // block of code to be executed if condition is true
  }

However, we often want something different to happen if the condition is false. For that, we can use the 'else' statement. The 'else' statement is used in conjunction with 'if' to execute a block of code if the condition is false. Here is an example:

  if (condition) {
    // block of code to be executed if condition is true
  } else {
    // block of code to be executed if the condition is false
  }

Sometimes we have multiple conditions to check. For that, we can use the 'else if' statement. 'Else if' is used after 'if' to check a new condition if the first condition is false. We can have as many 'else if' statements as we want. Here is an example:

  if (condition1) {
    // block of code to be executed if condition1 is true
  } else if (condition2) {
    // block of code to be executed if condition1 is false and condition2 is true
  } else {
    // block of code to be executed if both conditions are false
  }

Another important decision structure is the 'switch' statement. The 'switch' statement is used to select one of many blocks of code to be executed. It is a more readable and efficient alternative to a long string of 'if'-'else if'-'else' when we have many conditions to check. Here is an example:

  switch(expression){
    case value1:
      // block of code to be executed if expression equals value1
      break;
    case value2:
      // block of code to be executed if expression equals value2
      break;
    default:
      // block of code to be executed if the expression does not equal any of the values
  }

Decision flow control structures are fundamental in programming logic, as they allow our programs to make decisions and perform different actions depending on circumstances. In the next chapter, we'll explore looping flow control structures.

Next page of the Free Ebook:

1212. Flow control structures: repetition