C++ from the beginning - control flow
Tags: cpp, beginners, tutorial
Published: 2021-11-11 17:58:47

---
title: C++ from the beginning - control flow
published: true
series: C++ beginners
description: In this part, you'll focus on control flow, how to run some of the code some of the time. Additionally, also how to repeat certain instructions if you need to.
tags: cpp, beginners, tutorial
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/a6y0ky7qc3ljlo6brewo.jpg
---

> TLDR; this is a part of the series C++ for beginners, this part ia about control flows, the execution path taken through your program using constructs like `if`, `else`, `for` and `while`.

- [Your first program](https://dev.to/azure/c-from-the-beginning-2o2l)
- [Variables](https://dev.to/azure/c-from-the-beginning-variables-22nm)
- [Working with input and output](https://dev.to/azure/c-from-the-beginning-input-and-output-5ad0)
- [Functions](https://dev.to/azure/c-from-the-beginning-functions-5cnl)
- Control flow, **you are here**
- Working with files
- Pointers
- Error management
- Structs and Classes

## Resources

- [C++ module](https://docs.microsoft.com/en-us/learn/modules/cpp-first-program?wt.mc_id=academic-0000-chnoring)

## What is control flow and why should I care

A control flow is the order in which the instructions are executed. Consider the below code:

```cpp
int main() 
{
  int value = 3;
  cout << value;
  return 0;
}
```

In this example, we have a `main()`. The code will be executed from top to bottom, first the declaration of `value`, followed by the call to `cout`, to print the value and lastly to `return` statement. 

However, sometimes you want to change that flow, so it's not top to bottom. The reason for wanting that is that you might have a condition in your code that says execute these statements instead of that, or you might want to repeat a set of statements.

Let's look at how you can control the flow with `if` next up.

## If, a new execution path

By using `if`, you can declare in the code that if a certain condition holds true, then the code should do something different. Typically, your `if` constructs looks like so:

```cpp
if(condition) 
{
  // do something
}
```

The `if` construct wrapt a bool condition within parenthesis and uses curly braces to define what should happen if the condition evaluates to true. Here's an example:

```cpp
cout << "Welcome to your account\n";
int account_balance = 0;
if(account_balance > 0) 
{
  cout << "You can withdraw money"; 
}
```

Where we to run this code, it would only print "Welcome to your account" as `account_balance > 0` is `false`. To change that, we can modify `account_balance` and set it to 10 for example:

```cpp
cout << "Welcome to your account\n";
int account_balance = 10;
if(account_balance > 0) 
{
  cout << "You can withdraw money\n"; 
}
``` 

Now your code would print:

```output
Welcome to your account
You can withdraw money
```

What you saw here `account_balance > 0`, is a boolean expression, you could just replace it with the values true or false. 

## Else, then what to do

So far, we looked at using `if`, there's also `else`. `else` expresses that if the boolean expression for `if` is false, then `else` will be run. Therefore, `else` can't exist without `if`. 

To use `else`, you place it right after the `if`, it doesn't need a boolean expression. Let's modify the code from before to incorporate `else`:

```cpp
cout << "Welcome to your account\n";
int account_balance = 10;
if(account_balance > 0) 
{
  cout << "You can withdraw money\n"; 
}
else 
{
  cout << "No money, you can' withdraw\n";
}
``` 

With our addition of `else`, we know have another execution path, it will run `if` or `else`. Given the code above, it will run the `if`, let's change that:

```cpp
cout << "Welcome to your account\n";
int account_balance = 0;
if(account_balance > 0) 
{
  cout << "You can withdraw money\n"; 
}
else 
{
  cout << "No money, you can't withdraw\n";
}
```

If you run this, your program will say:

```output
Welcome to your account
No money, you can't withdraw
```

You might have another case, if you think about it, what if you balance is negative, that can happen. Looks look at that next with `else if`.

## Else-If, if `if` fails

Ok, so you have another condition that you want to test if `if` fails and it's a specific one, like checking for a negative balance? Great, that's when you should use `else if`. Like `if`, `else if` takes a condition within parenthesis. Also, just like `else`, it can't exist without `if`. Here's how we can modify our code to incorporate `else if`:

```cpp
cout << "Welcome to your account\n";
int account_balance = -10;
if(account_balance > 0) 
{
  cout << "You can withdraw money\n"; 
}
else if(account_balance < 0)
{
  cout << "You are overdrawn, please top up the balance to at least 0\n";
}
else 
{
  cout << "No money, you can't withdraw\n";
}
```

Where you to run this code, you would now get this output:

```cpp
Welcome to your account
You are overdrawn, please top up the balance to at least 0
```

As you can see, the `else if` is being hit. This program now has three different paths through it, `if`, `else if` and `else`.

## Loop constructs, repeat instructions

`if`, `else if` and `else` is way to make your code create different execution paths. Sometimes however, your code needs a different behavior, it needs to repeat a behavior until a condition is fulfilled.  Take an example where you want to keep the user in the program as long as they enter valid commands and only quit when the typed command equals the phrase "quit". Or imagine that you have an array of values, and you need to summarize them. In both these cases, you need a loop construct, albeit different types of loop constructs.

Let's look at the first one `while`.

### While, repeat until false

With `while`, you express that you want to repeat a set of instructions until false. Let's take the below code for example:

```cpp
int value = 3;
while(value < 5) 
{
  value++;
}
cout << "Value is" << value; // prints 5
```

The above will repeat this loop two times, as the first time, `value` will be 3 and incremented to 4. Next iteration, 4 will be incremented to 5. The last time, it will fail the check as the value is 5.

Here's another example, that you can use to create command-based console programs:

```cpp
string user_input = "";

while(true)
{
  cout << "Type a command: ";
  getline(cin, user_input);
  if(user_input == "quit") 
  {
    break;
  }
  cout << "You typed: " << user_input;
  if(user_input == "hello") 
  {
    cout << "Greetings";
  } else {
    cout << "Unknown command: " + user_input; 
  }
  // add command definitions here
}
cout << "Bye";
```

A possible program execution of the above could be:

```output
> Type a command: hello
> Greetings
> Type a command: help
> Unknown command: help
> Type a command: quit
> Bye
```

Note the use of `break` in this code:

```cpp
if(user_input == "quit") 
{
  break;
}
```

Calling `break` while stop the loop from looping. 

## for, when you know more about what you loop

There's another looping construct that it's good to know about, `for`. `for`, just like `while` allows you to repeat instructions until a condition is met. Where it differs is that with a `for` loop, you have additional concepts, an index variable that keeps track of starting point, a comparison point and increment point. Here's an example:

```cpp
// will print values 0-9
for(int i=0; i< 10; i++) 
{
  cout << i;
}
```

There are three parts here:

- `int i = 0`, this is where you initialize a variable
- `i < 10`, for every iteration, the loop construct will test this comparison, if it results in false then looping will stop
- `i++`, this is where i++ gets incremented for every iteration.

A more real example can be iterating a set of records, let's say actions on a bank account:

```cpp
vector<int> transactions;
transactions.push_back(100);
transactions.push_back(-50);
transactions.push_back(-25);
transactions.push_back(50);
int sum = 0;
for (vector<int>::size_type i = 0; i < transactions.size(); i++)
{
  sum += transactions[i];
}

cout << "Your account balance is: " << sum;
```

`transactions` are being iterated over, and for each item in its collection, the value is added to `sum`.

## Summary

You've learned about `if`, `else if` and `else`. These constructs are used to create different execution paths in your program. Your code will select one of these paths. Additionally, you were told about while and for loops that's used to repeat instructions. `for` is different from `while` as you have the idea of a variable that keeps tracks of what looping iteration you are on.