Summer’s over — what’s your move? Join Pro for 50% off using code [MAKEITHAPPEN](https://www.codecademy.com/checkout?periods=year&plan_id=proGoldAnnualV2&discountCode=MAKEITHAPPEN)


In this lesson, we will explore how programs make decisions by evaluating conditions and introduce logic into our code!

Conditionals & Logic

An `if` statement is used to test an expression for truth and execute some code based on it. Here's a simple form of the `if` statement:

```pseudo
if (condition) {

  some code

}
```

If the *condition* is `true`, then the *statements* within are executed. Otherwise, the *statements* are skipped and the program continues on.

```cpp
if (flip == 1) {
  
  std::cout << "Heads\n";
  
}
```

The `if` keyword is followed by a set of parentheses `()`. Inside the parentheses `()`, a condition is provided that evaluates to `true` or `false`:

- If the condition evaluates to `true`, the code inside the curly braces `{}` executes.
- If the condition evaluates to `false`, the code won't execute.

So in the code above, if `flip` is equal to 1, the program outputs "Heads"; if it does not, then nothing happens and the program continues.

If Statement

Now that we know how `if`, `else if`, `else` work, we can write programs that have multiple outcomes. Programs with multiple outcomes are so common that C++ provides a special statement for it... the `switch` statement!

A [`switch`](https://www.codecademy.com/resources/docs/cpp/switch?page_ref=catalog) statement provides an alternative syntax that is easier to read and write. However, you are going to find these less frequently than `if`, `else if`, `else` in the wild. 

A `switch` statement looks like this:

```cpp
switch (grade) {
  
  case 9:
    std::cout << "Freshman\n";
    break;
  case 10:
    std::cout << "Sophomore\n";
    break;
  case 11:
    std::cout << "Junior\n";
    break;
  case 12:
    std::cout << "Senior\n";
    break;
  default:
    std::cout << "Invalid\n";
    break;

}
```

- The `switch` keyword initiates the statement and is followed by `()`, which contains the value that each case will compare. In the example, the value or expression of the switch statement is `grade`. One restriction on this expression is that it must evaluate to an integral type (`int`, `char`, `short`, `long`, `long long`, or `enum`).
- Inside the block, `{}`, there are multiple cases.
- The `case` keyword checks if the expression matches the specified value that comes after it. The value following the first case is `9`. If the value of `grade` is equal to `9`, then the code that follows the `:` would run.
- The `break` keyword tells the computer to exit the block and not execute any more code or check any other cases inside the code block.
- At the end of each switch statement, there is a `default` statement. If none of the cases are `true`, then the code in the `default` statement will run. It's essentially the `else` part.

In the code above, suppose `grade` is equal to `10`, then the output would be "Sophomore".

**Note:** Without the `break` keyword at the end of each case, the program would execute the code for the first matching case and *all* subsequent cases, including the `default` code. This behavior is different from `if` / `else` conditional statements which execute only one block of code.

Switch Statement

Congratulations! 🙌

Here are some of the major concepts:

- An `if` statement checks a condition and will execute a task if that condition evaluates to true.
- `if` / `else` statements make binary decisions and execute different code blocks based on a provided condition.
- We can add more conditions using `else if` statements.
- [Relational operators](https://www.codecademy.com/resources/docs/cpp/operators?page_ref=catalog), including `<`, `>`, `<=`, `>=`, `==`, and `!=` can compare two values.
- A [`switch`](https://www.codecademy.com/resources/docs/cpp/switch?page_ref=catalog) statement can be used to simplify the process of writing multiple `else if` statements. The `break` keyword stops the remaining cases from being checked and executed in a switch statement.

Review

Before we dive deep into the syntax of the `if` statement, let's do a demo!

<img src="https://content.codecademy.com/courses/learn-cpp/conditionals-and-logic/coinflip.gif" alt="Coin Toss" title="Coin Toss">

Here, we have **coinflip.cpp** program that simulates a coin toss:

- 50% of the time, it's Heads.
- 50% of the time, it's Tails.


Coin Flip Demo

So what happens if you want more than two possible outcomes?

This is where `else if` comes in!

```pseudo
if (condition) {

  some code

} else if (condition) {

  some code

} else {

  some code

}
```

The `else if` statement always comes after the `if` statement and before the `else` statement. The `else if` statement also takes a condition. 

And you can have more than one of them! Here's an example with three of them:

```cpp
if (grade == 9) {
  
  std::cout << "Freshman\n";

} 
else if (grade == 10) {
  
  std::cout << "Sophomore\n";
  
}
else if (grade == 11) {

  std::cout << "Junior\n";
  
} 
else if (grade == 12) {
  
  std::cout << "Senior\n";

}
else {

  std::cout << "Super Senior\n";

}
```

Else If

Every program we've seen so far has only had one possible path of execution — they all execute line by line, from top to bottom. And every time you run one of those programs, it gives you the same exact result. But it's the twenty-first century, and we like options!

In this lesson, we will explore how programs make decisions by evaluating conditions and introduce logic into our code! 

We'll be covering the following concepts:

- `if`, `else if`, and `else` statements
- [`switch`](https://www.codecademy.com/resources/docs/cpp/switch?page_ref=catalog) statements
- [Relational operators](https://www.codecademy.com/resources/docs/cpp/operators?page_ref=cataloglink)
- [Logical operators](https://www.codecademy.com/resources/docs/cpp/operators?page_ref=catalog)

So... *if* you've already learned these concepts in another language, go to the next lesson — *else*, prepare yourself and let's get started!




Conditionals Street sign at a fork in the road showing options for True and False.

Introduction to Conditionals & Logic

When writing conditional statements, sometimes we need to use different types of operators to compare values. These operators are called [*relational operators*](https://www.codecademy.com/resources/docs/cpp/operators?page_ref=catalog).

To have a condition, we need relational operators:

- `==` equal to
- `!=` not equal to
- `>` greater than
- `<` less than
- `>=` greater than or equal to
- `<=` less than or equal to

Relational operators compare the value on the left with the value on the right. 

Relational Operators

We can also add an `else` clause to an `if` statement to provide code that will only be executed if the condition is `false`. Here's a form of an `if` statement that includes an `else` clause:

```pseudo
if (condition) {

  do something

} else {

  do something else

}
```

- If *condition* is `true`, *statement1* is executed. Then the program *skips* *statement2* and executes any code statements following the `if`/`else` clause. 
- If *condition* is `false`, *statement1* is *skipped* and *statement2* is executed. After *statement2* completes, the program executes any code statements following the `if`/`else` clause.

```cpp
if (coin == 1) {

  std::cout << "Heads\n";

}
else {
  
  std::cout << "Tails\n";
  
}
```

So in the code above, if `coin` is equal to 1, the program outputs "Heads"; if it does not, then it outputs "Tails".


**Note:** It's either or — only one of them will execute!

