Conditionals: Lesson

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:

```c
if (condition) {
  // Statement(s)
}
```

If the _condition_ is `true`, then the _statements_ within the `if` block are executed. These statements are any lines of code that would otherwise be normally executed by the program. When the condition is `false`, the inside statements are skipped and the program continues on.

```c
if (flip == 1) {
  printf("Heads\n");
}
```

The `if` keyword is followed by a set of parentheses `()`. Inside these 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 doesn'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

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

![title](https://content.codecademy.com/courses/learn-cpp/conditionals-and-logic/coinflip.gif)

Here, we have a **coinflip.c** program that simulates a coin toss:
- 50% of the time, it’s Heads.
- 50% of the time, it’s Tails.

Coin Flip Demo

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

```c
if (condition) {
  // Statement1 — do something
} else {
  // Statement2 — 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.

```c
if (coin == 1) {
  printf("Heads\n");
} else {
  printf("Tails\n");
}
```

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!

else Clause

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

This is where `else if` comes in!

```c
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 (if there is one). Like the `else` statement, `else if` statements are also always optional!

The `else if` then takes a condition, and you can have more than one of them. Here’s an example with three of them:

```c
if (grade == 9) {
  printf("Freshman\n");
} else if (grade == 10) {
  printf("Sophomore\n");
} else if (grade == 11) {
  printf("Junior\n");
} else if (grade == 12) {
  printf("Senior\n");
} else {
  printf("Super Senior\n");
}
```

else if

Now that we know how `if`, `else if`, and `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` statement provides an alternate syntax that is easier to read and write. However, you are going to find these less frequently than `if`, `else if`, and `else`s in the wild.

A `switch` statement looks like this:

```c
switch (grade) {
  case 9:
    printf("Freshman\n");
    break;
  case 10:
    printf("Sophomore\n");
    break;
  case 11:
    printf("Junior\n");
    break;
  case 12:
    printf("Senior\n");
    break;
  default:
    printf("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

We’ve already seen _relational operators_ at work. Conditionals incorporate them in all their forms.

For example, we can do something like:

```c
if (grade >= 60) {
  // Do something
}
```

In much the same fashion, we could’ve used a `<=`, or `!=`, or even `==`. These relational operators naturally result in true or false expressions, which make them perfect for conditionals!

However, sometimes we need to write multiple conditions in one conditional statement. In a past lesson, we learned about _logical operators_. We can use these operators here as well!

Let’s recap the logical operators:
- `&&` AND
- `||` OR
- `!` NOT

When placed in a conditional statement, logical operators work together to produce one `true` or `false` output across multiple conditions.

For example:

```c
if (a > 0 && b > 0) {
  printf("Positive\n");
}
```

The above conditional checks if _both_ conditions are `true`, and if they both are, the `if` statement passes. If either `a` or `b` was a negative number, the `if` statement would be `false`.

Working with Operators

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 introduce logic into our code and explore how programs make decisions by evaluating conditions!

We’ll be covering the following concepts:
- `if`, `else if`, and `else` statements
- `switch` statements
- Relational and Logical operators
- Ternary operators

So… _if_ you’ve already learned these concepts in another language, go to the next lesson — _else_, prepare yourself and let’s get started!

Introduction

We’ve learned that the `if` / `else` statement is versatile. It's so versatile that C actually has a built-in special way to shortcut an `if` / `else` statement into one line. And you don’t even need to use the words "if" and "else!"

This shortcut is called a _ternary operator_. It’s most applicably used when an `if` / `else` statement returns a value, but can also work otherwise. For instance, deciding what to output in a print statement. A ternary operator looks like this:

```c
condition ? do something : do something else;
```

The above example is exactly the same as:

```c
if (condition) {
  // Do something
} else {
  // Do something else
}
```

This operator acts exactly like an `if` / `else` statement! For example, let’s take a look at the following statement:

```c
if (a < b) {
  min = a;
} else {
  min = b;
}
```

The above `if` / `else` statement compares `a` and `b` and stores the smaller of the two inside the `min` variable. Let’s rewrite this as a ternary operator:

```c
min = a < b ? a : b;
```

The `?` marks the check for the condition, as if asking it as a question. If `a` is the smaller number, the condition passes with true, which executes the left-hand side of the `:` and stores `a` into `min`. If the condition was false, then the right-hand side of the `:` executes, which stores `b` into `min` instead.

Ternary Operators

Congratulations on completing the lesson on conditionals! 🙌

Let's review some of the major concepts from the lesson:
- 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, including `<`, `>`, `<=`, `>=`, `==`, and `!=` can compare two values.
- Logical operators, including `&&`, `||`, and `!` can allow multiple conditions in one conditional statement.
- A `switch` 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.
- A ternary operator can be used to simplify the process of an `if else` statement.