Numbers and Literals

Welcome to our exploration of numeric variables! In this lesson, we explore numeric data types and their operations in C++.

Building on our previous discussion about integers and floating-point numbers, we will expand your understanding of how numbers work in C++ and how you can manipulate them.

As a reminder, here is how we create variables. This is similar to what we saw in the previous chapter, except we're now also showing the creation of a float type. A float is a number with a decimal point:

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

1int LargeNumber { 100'000'000 };

Basic Arithmetic Operators

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 };

Variables with Maths

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;

Increment and Decrement Operators

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.

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

Compound Assignment

Additionally, we have further operators to provide a quicker way of implementing 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;

Negative Numbers

We have access to negative numbers

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. We’ll discuss what "unary" means later in the course.

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

Integer Division

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 5/2 expression 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 };

Floating Point Numbers

In the previous example where we cout 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.

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

Floating Point Operations

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...

1float VariableA { 3.14 };
2float VariableB { 3.14f };

1float VariableA { 4. };
2float VariableB { 4.f };

Summary

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.
• Negative Numbers and Different Integer Types: Discussed the use of negative numbers and explored various integer types available in C++.
• Signed vs. Unsigned Integers: Examined the concept of signed and unsigned integers and their implications.
• Overflows and Memory Considerations: Highlighted the potential issues with overflows in numeric operations.

Preview of the Next Lesson: Boolean Variables

In our next lesson, we'll shift our focus to another fundamental aspect of programming: Boolean variables. This upcoming session will include:

• Introduction to Boolean Logic: Understanding the true/false nature of Boolean variables.
• Using Booleans in Conditional Statements: Learn how to use Boolean variables in decision-making processes within your code.
• Boolean Operators: We'll explore logical operators (AND, OR, NOT) and how they are used to form complex logical expressions.
• Practical Applications of Booleans: Discover how Boolean variables are integral in control structures such as loops and conditional statements.

Next Lesson

Booleans - true and false values

An overview of the fundamental true or false data type, how we can create them, and how we can combine them.

ContinueView Course