Numbers

1bool isDead { false };
2int Level { 5 };
3float Armor { 0.2 };
4int LargeNumber { 100000000 };

We can do all the standard maths operations to our numbers. This includes all the basic operators:

• + for addition
• - for subtraction
• * for multiplication
• / for division

For example, we can use a mathematical expression when setting the initial value of our variable, or updating it:

1// Level is initialized with a value of 5
2int Level { 2 + 3 };
3
4// It is then updated with the value of 10
5Level = 5 * 2;

Here are some more examples:

1// Level is initialized with a value of 5
2int Level { 2 + 3 };
3
4Level = 5 + 1; // Level is 6
5Level = 5 - 1; // Level is 4
6Level = 5 * 2; // Level is 10
7Level = 6 / 2; // Level is 3
8Level = 1 + 2 + 3; // Level is 6

Order of Operations

The order of operations applies in C++ just as it does in maths. Operations are not always performed left-to-right.

For example, multiplication happens before addition, so our following code will result in Level having a value of 7.

The 2 * 3 part of our expression will happen first, then 1 will be added to that result:

1// Level is initialized with a value of 7
2int Level { 1 + 2 * 3 };

As with maths, we can introduce brackets - ( and ) - to manipulate the order of operations. Expressions in brackets happen first:

1// Level is initialized with a value of 9
2int Level { (1 + 2) * 3 };

We can use the values contained in other variables within our arithmetic expressions:

1int StartingHealth { 500 };
2int Lost { 100 };
3
4// This will have a starting value of 400
5int RemainingHealth { StartingHealth - Lost };

We can also use the current value of the variable when updating it, using an expression like this:

1int Level { 5 };
2Level = Level + 1;  // Level is now 6

1int BaseHealth { 200 };
2int HealthBuff { 2 };
3int Health { BaseHealth * HealthBuff };

1int Level { 10 };
2int Level = Level + 1;

The above example of increasing the value contained in a variable by 1 is so common, that programming languages often offer a quicker way of writing it.

Increasing a value by one is commonly called incrementing, and it has a dedicated operator: ++.

The operator can go before or after the variable. There is a subtle difference, which we'll discuss in a later chapter, but for now we can use them interchangeably:

1int Level { 5 };
2Level++;  // Level is now 6
3++Level;  // Level is now 7

We also have the -- operator for decrementing:

1int Level { 5 };
2Level--;  // Level is now 4
3--Level;  // Level is now 3

Additionally, we have further operators to provide a quicker way of updating existing variables using arithmetic. These are referred to as compound assignment operators

For example, += will increase the variable on the operator's left by the value on the right.

1int Level { 5 };
2Level += 3;  // Level is now 8

We also have the -=, *=, and /= operators to apply subtraction, multiplication, or division in the same manner

1int Level {8};
2Level -= 3; // Level is now 5
3Level *= 3;  // Level is now 15
4Level /= 5; // Level is now 3
5
6Level *= Level; // Level is now 9

1int Level { 2 };
2Level = Level * Level + 2;
3Level -= 2;

We have access to negative numbers using the - symbol:

1int NegativeValue { -5 };

They behave exactly like they would in maths

1int Health { 100 };
2int HealthModifier { -10 };
3
4Health += HealthModifier; // Health is now 90
5
6Health *= -1; // Health is now -90

When used like this, - is another example of an operator. It is referred to as the unary minus.

The implication of - being an operator means it doesn't necessarily only appear before numbers - it can be applied more widely.

For example, we can access the negative form of a variable, or another expression, by prefixing it with -:

1int Input { 4 };
2int Result { -Input }; // Result is -4
3Result = -(Input + 2); // Result is -6

What would the result be of dividing 5 by 2?

1#include <iostream>
2using namespace std;
3
4int main(){
5  cout << "5 / 2 = " << 5 / 2;
6}

Perhaps surprisingly, C++ says it is 2:

15 / 2 = 2

We may have expected it to be 2.5. However, dividing an integer by an integer always yields an integer.

So why is it not 3? The specification of the built-in int data type is to discard any floating point component - not to round it. So, this leaves us with the integer 2.

This is true whatever we do with the result of the expression. Above, we are logging it out, but we could also be assigning it to a variable, even a floating point variable:

1// IntegerLevel is 2
2int IntegerLevel { 5/2 };
3
4// FloatingLevel is 2.0
5float FloatingLevel { 5/2 };

Even though we're assigning the result of the expression to a floating point variable that could store 2.5, the evaluation of 5/2 happens first.

5/2 resolves to 2, and then we convert 2 to a float, which yields 2.0.

1int Level { 3 / 2 };

1float Level { 1 / 2 };

In the previous example where we cout the result of our division, we saw that the division of two integers always yields an integer. If either, or both, of the values in the expression were floating point numbers, we would get a floating point output instead.

All of these examples would log out 2.5:

1cout << 5.0/2;
2cout << 5/2.0;
3cout << 5.0/2.0;

This is also true for the other basic maths operations. Combining a float and an integer in the same operation yields a float, regardless of whether the float is on the left or the right side of the operator:

15 + 1.0; // 6.0
25.0 + 1; // 6.0
3
45 - 1.0; // 4.0
55.0 - 1; // 4.0
6
75 * 2.0; // 10.0
85.0 * 2; // 10.0
9
105.0 / 2; // 2.5
115 / 2.0; // 2.5

We can create floating point variables in the way you might expect:

1float Health { 2.5 };

A float variable can be initialized with an integer value, which will be converted to its floating-point representation

1float Health { 5 }; // Health is 5.0

Like with any other variable, we can initialize it with an expression. For example, this can be the result of a maths operation, or the value contained in another variable:

1// MaxHealth is 2.5
2float MaxHealth { 5.0 / 2.0 };
3
4// CurrentHealth is 2.5
5float CurrentHealth { MaxHealth };

Remember, the expression is calculated before the variable type is considered.

In the below example, we perform integer division to yield 5 / 2 = 2. We then assign the integer 2 to the float Health, which will convert it to the floating point number 2.0

1float Health { 5/2 }; // Health is 2.0

All the operators we've seen for integers are also available to floating point numbers.

1float Health { 5.0 }; // Health is 5.0
2Health = Health + 20.0; // Health is now 25.0
3Health++; // Health is now 26.0
4Health--; // Health is now 25.0
5
6// We can freely combine floating and
7// integer numbers in the expressions
8Health += 25; // Health is now 50.0
9Health -= 10; // Health is now 40.0
10Health *= 2.5; // Health is now 100.0
11Health /= 3; // Health is now 33.3333...

In this lesson, we journeyed through the fundamentals of numeric variables in C++, covering key concepts:

• Variable Creation and Types: We revisited creating variables in C++, emphasizing the addition of the float type for numbers with decimal points.
• Numeric Operations and Syntax: Explored arithmetic operations (+, -, *, /) and their use.
• Thousand Separators: Introduced the use of single quotes as thousand separators for readability in large numbers.
• Increment and Decrement Operators: Learned about shorthand operators (++, --) and their significance in simplifying code.
• Compound Assignments: Discussed compound assignment operators (+=, -=, *=, /=) for efficient value manipulation.
• Understanding Integer and Floating-Point Division: Addressed how C++ handles division, especially the distinction between integer and floating-point division.