Numbers and Literals

Welcome to our exploration of numeric variables in C++! In this lesson, we dive deeper into the world of numeric data types and their operations.

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

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 left of the operator 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 {5};
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 Types

So far, we've just been using the simple int data type for storing our integers, but there are other options. C++ has many different integer types, with names such as short int and unsigned long int

Why would there be multiple integer types? One reason is to give us options for how much memory we want to allocate for our number.

For example, if our maximum Level is 50, we don't need to allocate enough memory for that variable to store huge numbers. 8 bits of memory would be enough - that would allow for 256 possible values in that space.

If we use a variable that has more bits, we can store a wider range of values, at the expense of our software using some additional resources. 16-bit integers can store 65,536 different possibilities; 32 bits could store over 4 billion

The specifics of the different types of integers and their memory usage aren't that important at this stage. The basic int will have enough bits for our needs. It's just worth noting at this stage that there are many different types of integers. You may see alternatives being used in other places.

Signed and Unsigned Integers

Another reason we have different types of integers is to give us more options on how we use the memory. We saw how 32 bits of memory give us access to around 4 billion different possible integers. But what range of integers should we map to those options?

We could use a range from around negative 2 billion to positive 2 billion. But, what if we knew our variable could never be negative? We're wasting half of that range.

A number that cannot be negative is said to be unsigned. We can create an unsigned integer like this:

1unsigned int Health { 5 };

This makes the intent of what our variables will contain clearer for anyone reading our code. In addition, our health values can get to be twice as large before our variable runs out of available memory.

Overflows

Unfortunately, there is a major drawback with unsigned integers. Even for values we don't ever want to be negative, such as a Health value, using an unsigned number can cause a lot of pain.

Something weird happens when we push a number beyond its range. This is called an overflow and it happens when we decrease a number below its lower limit or increase a number above its upper limit.

With an unsigned integer, its lower limit is 0. An unsigned int cannot go below 0 - if our code causes that to happen, we will create an overflow.

Let's imagine we have an unsigned int that currently has a value of 0, and we cause an overflow by subtracting 1 from it:

1#include <iostream>
2using namespace std;
3
4int main() {
5  unsigned int Health { 0 };
6  Health -= 1;
7  cout << Health;
8}

The effect is not that Health remains at 0. Rather, it wraps around to its other extreme. The previous program’s output is:

14294967295

This seems likely to cause some issues!

Having our variables regularly store values that are at the extremes of their range makes our lives a lot more difficult. We could always be mindful of this and constantly code against overflows, but it's a pain and generally not worth it.

Rather, we should design our software so that our variables are not constantly close to overflowing.

As a result, this means using unsigned integers for any variable we're going to be performing arithmetic on is generally not recommended.

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

The float data type also can be created from an integer

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

Doubles and Other Float Types

Like with integers, we have different options for how much memory we want our floating point number to consume. Unlike integers, however, floating points are often implemented slightly differently in terms of how they use their memory.

What changes when we give floating point numbers more memory is how precise they are. More bits allow them to store more "significant figures", increasing their accuracy.

The most common data types for floating point numbers are float and double. A double is given the name because it uses double the number of bits as a regular float. This means a double is more precise than float at the expense of consuming more memory.

This is also the source of the phrase "double precision", which you may have heard in the context of science or programming.

The basic float will be sufficient for our needs. What's important is just to recognize that there are different options, and you may see them being used in other code samples.

Literals and Conversions

We've been using literals quite a lot already, but it's worth taking a moment to explain them in a bit more depth.

When we write an expression like 4.0 or "Goblin Warrior", we are using a literal. A literal is a way of expressing a fixed value in our code.

Like variables, literals also have a type. Rather than needing to explicitly state it, the type of a literal is instead inferred based on the specific syntax we use. For example,

• 6 is an int literal
• 4.0 is a double literal
• 4.0f (with an f suffix) is a float literal
• 'a' (straight single quotes) is a char literal
• "Goblin Warrior" (straight double quotes) is a char* literal - a type which we’ll cover later in the course
• "Goblin Warrior"s (straight double quotes and s suffix) is a string literal

We’ve seen in previous code examples that conversions from these literals into other types can often be done automatically We’ve been creating float objects from double literals, and string objects from char* literals:

1// Creating a float from a double literal
2float MyNumber { 4.0 };
3
4// Creating a string from a char* literal
5string MyString { "Goblin Warrior" };

If preferred, we can add the f and s suffix to our floats and strings. The previous code could be written like this:

1float MyNumber { 4.0f };
2string MyString { "Goblin Warrior"s };

To make our code samples as simple as possible for beginners, we will not include the f and s, except in the rare scenarios where doing so makes a difference. In those situations, we will point it out and explain why.

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