Getting our machines set up for C++ development, and introducing the fundamental building blocks of programming - variables.

Getting our computer set up so we can create and build C++ programs. Then, creating our very first application

Setting up a C++ Development Environment

An introduction to the building blocks of our software - objects, and the variables that can be associated with them.

Objects, Variables and Types

Creating variables to store and update the data that describes our objects.  We also introduce comments, allowing us to describe our code in plain language.

Creating Variables

An introduction to the different types of numbers in C++, and how we can do basic math operations on them.

Numbers

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

Booleans - `true` and `false` values

Explore how C++ programs store and manage numbers in computer memory, including integer and floating-point types, memory allocation, and overflow handling.

Types and Literals

Creating a tiny program using numbers and booleans, then adding some breakpoints so we can step through our code in a debugger.

Introduction to Debugging

Types and Variables

Discover how we can package our code into reusable functions that we can easily call.  Then, learn how we can use conditionals and loops to control the flow of our program.

An introduction to functions - reusable blocks of code that we can use to break our application into smaller pieces.

Creating and Calling Functions

An introduction to how our function calls create a call stack, and how we can navigate it in a debugger.

The Call Stack and Debugging Functions

Use booleans and if statements to make our functions and programs more dynamic, choosing different execution paths.

Conditional Logic

Learn an alternative way to write conditionals, which is often used when we want to take different paths based on a specific value

Switch Statements

Allow our functions to communicate with their caller by returning values when they complete

Function `return` Statements

Going into more depth on what is happening when a variable is used as a different type

Implicit Conversions and Narrowing Casts

Making our functions more useful and dynamic by providing them with additional values to use in their execution

Function Arguments and Parameters

Learn more about how and when we can access variables, by understanding the importance of the scope in which they exist.

Scope

Understand what function prototypes are, and learn how we can use them to let us order our code any way we want.

Forward Declarations

Learn how we can use loops to iterate over a block of code, executing it as many times as needed.

Loops

Learn how we can use the modulus operator to get the remainder of integer division, and some common use cases.

The Modulus Operator (`%`)

Put everything we've learned in this chapter to the test by creating a C++ version of the Fizz Buzz game.

Fizz Buzz

Learn how the `&&` and `||` operators are optimized with short-circuit evaluation, only evaluating expressions when necessary

Short-circuit Evaluation

Functions, Conditionals and Loops

Classes and structs are the fundamental feature of object oriented programming.  In this chapter, we will see how we can set them up, and how we can use them to create the custom types our program needs.

Learn how to define, instantiate, and utilize classes, understanding how they form the backbone of object-oriented programming.

Abstraction and Classes

A guide to encapsulation, class invariants, and controlling data access with `public` and `private` specifiers.

Encapsulation and Access Specifiers

Learn about special functions we can add to our classes, control how our objects get created and destroyed.

Constructors and Destructors

Discover the role of structs, how they differ from classes, and how to initialize them without requiring a constructor.

Structs and Aggregate Initialization

This lesson introduces operator overloading, a fundamental concept to create more intuitive and readable code by customizing operators for user-defined types

Operator Overloading

This lesson introduces Structured Binding, a handy tool for unpacking simple data structures

Structured Binding

Classes and Structs

See how we can use inheritance to organise our classes into a hierarchy, unlocking a massive range of possibilities for building more complex software

In this lesson, we explore C++ inheritance, guiding you through creating and managing class hierarchies to streamline your code

Inheritance

Learn about `protected` class members in C++, including how and when to use them in your code, especially in the context of inheritance and class design

Protected Class Members

This lesson introduces Member Initializer Lists, focusing on their advantages for performance and readability, and how to use them effectively

Member Initializer Lists

This lesson provides an in-depth exploration of using inherited methods and variables in C++, covering constructor calls, variable modification, and function shadowing

Working with Inherited Members

An introduction to working with memory, and how we represent memory locations using references and pointers

This lesson introduces references, explaining how they work, their benefits, and their role in performance and data manipulation

References

This lesson provides a thorough introduction to pointers in C++, covering their definition, usage, and the distinction between pointers and references

Pointers

Learn about the `this` pointer in C++ programming, focusing on its application in identifying callers, chaining functions, and overloading operators.

The `this` Pointer

Learn about an important consideration when returning pointers and references from functions

Dangling Pointers and References

Memory, References and Pointers

An introduction to polymorphism - the key tool that let us build more complex programs whilst keeping our code simple.

This lesson provides an in-depth look at function overloading in C++, covering its importance, implementation, and best practices

Function Overloading

Explore the concept of static casting in C++, including examples and best practices for converting data types at compile time

Static Casting

This lesson provides an introduction to virtual functions and overrides, focusing on their role in enabling runtime polymorphism

Virtual Functions and Overrides

Get to grips with downcasting in C++, including static and dynamic casts. This lesson provides clear explanations and practical examples for beginners

Downcasting

Polymorphism

Go deeper on what is happening when we build our software.  Learn how we can use the preprocessor to automatically modify our source code before it is compiled, and how the linker connects our program together.

Explore the essential concepts of C++ preprocessing, from understanding directives to implementing macros

Preprocessor Definitions

Discover how the `#include` directive helps us include library features and split our project across multiple files.

The `#include` Directive

Explore how header files and linkers streamline C++ programming, learning to organize and link our code effectively

Header Files

The Preprocessor and the Linker

Discover additional methods and techniques to keep our data and code organised.

Learn the essentials of using namespaces to organize your code and handle large projects with ease

Namespaces

Learn about Enums and how they offer an efficient way to handle predefined values in your code

Enums

This lesson introduces the `using` keyword in C++, focusing on namespaces, enums, and type aliasing

The `using` Keyword

Namespaces and Enums

Learn how to store collections of objects, and take control of how memory is managed

Explore the fundamentals of dynamic arrays with an introduction to `std::vector`

Dynamic Arrays using `std::vector`

Learn how to manage dynamic memory using unique pointers and the concept of memory ownership

Memory Ownership and Smart Pointers

Explore advanced techniques for managing object copying and resource allocation

Copy Constructors and Operators

Learn the techniques and pitfalls of manual memory management in C++

Managing Memory Manually

Arrays and Dynamic Memory

Techniques to simplify our code, making it easier to understand and maintain

This lesson covers how we can ask the compiler to infer what types we are using through the `auto` keyword

Automatic Type Deduction using `auto`

Learn the intricacies of using `const` and how to apply it in different contexts

Constants and `const`-Correctness

This lesson provides an overview of effective commenting strategies, including Javadoc style commenting for automated documentation

Effective Comments and Javadoc

This lesson introduces the concept of Style Guides and ClangFormat, focusing on how to achieve consistency in our code

Style Guides and Automatic Code Formatting

An introduction to static analysis tools, and how they can help beginners learn faster and improve code quality

Static Analysis

Explore the fundamentals of attributes, including `[[nodiscard]]`, `[[likely]]`, and `[[deprecated]]`

Attributes

Clean Code

A collection of lessons covering a variety of topics worth learning as a beginner

This lesson covers the basics of using randomness, with practical applications

Random Number Generation

Learn the basics of the chrono library and discover how to effectively manage durations, clocks, and time points

Dates, Times and Durations

A detailed guide to string formatting using C++20's `std::format()`, and C++23's `std::print()`

String Interpolation

Learn how to overload the `<<` operator, so our custom types can stream information directly to the console using `std::cout`

Overloading the `<<` Operator

This lesson introduces system calls, and how to use them to clear the terminal

System Calls and Terminal Management

This lesson introduces the fundamentals of capturing user input, using `std::cin` and `std::getline()`

User Input in the Terminal

Unravel the fundamentals of bitwise operators and bit flags in this practical lesson

Bitwise Operators and Bit Flags

Odds and Ends

This course is designed for beginners. We'll take you from the fundamentals and lay a solid foundation for creating real-world programs and learning more advanced concepts.

Become a software engineer with C++.  Starting from the basics, we guide you step by step along the way

This course teaches the fundamentals of C++ while instilling habits used by real-world developers. You'll gain practical experience with concepts that are the foundation of all modern programming.

No previous programming experience is needed - we start from the basics.

Start your Journey

We explain every line of code we're using, so you understand exactly what is happening.

Understand Every Line of Code

Everything we create is organised and implemented using modern, professional practices.

Use Professional Best Practices

We don't just explain what we're doing, but also why. This builds transferrable skills, so you can take what you've learnt and apply them to your own projects.

Focus on Transferrable Skills

No paywalls, no ads - the course is completely free with unlimited access

Free and Unrestricted Access

We break complex concepts into manageable steps, making even advanced topics feel approachable.

Step-by-Step Learning

What You'll Learn

Comprehensive course covering advanced concepts, and how to use them on large-scale projects.

Professional C++

If you're already familiar with the basics of C++ and object oriented programming, you may want to skip to the advanced course.  It starts with a quick summary of everything we cover here.

Already Familiar with Programming?

Intro to C++ Programming

Dividing by zero in C++ can lead to different behaviors depending on whether you're working with integer or floating-point numbers.


## Integer Division by Zero


When you divide an integer by zero, your program will crash due to a hardware exception. This is actually good - it helps you catch errors early:


```c++
#include <iostream>
using namespace std;

int main() {
  int health{100};
  int divisor{0};

  // Program crashes here
  int result{health / divisor}; //<e> 

  cout << "This line never executes";
}
```


```plain text
//<oe>
Arithmetic exception: divide by zero
```


## Floating-Point Division by Zero


Floating-point division by zero behaves differently - instead of crashing, it gives you special values:


```c++
#include <iostream>
using namespace std;

int main() {
  float health{100.0f};
  float divisor{0.0f};

  float result{health / divisor}; //<h>
  cout << "Result: " << result << "\n";

  float negativeHealth{-100.0f};
  float negativeResult{
    negativeHealth / divisor}; //<h>
  cout << "Negative result: "
    << negativeResult << "\n";

  float zero{0.0f};
  float undefined{zero / zero}; //<h>
  cout << "Zero divided by zero: " << undefined;
}
```


```plain text
//<o>
Result: inf
Negative result: -inf
Zero divided by zero: nan
```


The program produces three special values:

- `inf` (infinity) when dividing a positive number by zero
- `inf` (negative infinity) when dividing a negative number by zero
- `nan` (not a number) when dividing zero by zero

In real programs, you should check for division by zero before performing the operation. Here's a safer way:


```c++
#include <iostream>
using namespace std;

float safeDivide(float numerator,
                 float divisor) {
  if (divisor == 0.0f) {
    cout << "Warning: Division by zero!\n";
    return 0.0f; // Or another appropriate value
  }
  return numerator / divisor;
}

int main() {
  float health{100.0f};
  float divisor{0.0f};

  float result{safeDivide(health, divisor)};
  cout << "Result: " << result << "\n";
}
```


```plain text
//<o>
Warning: Division by zero!
Result: 0
```

Division by Zero in C++

While `Level++` and `++Level` might appear to do the same thing when used alone, they actually behave differently when used within larger expressions. Let's explore the difference:


## Basic Behavior


When used in isolation, both increment the variable by 1:


```c++
#include <iostream>
using namespace std;

int main() {
  int levelA{5};
  int levelB{5};

  ++levelA; // Pre-increment
  levelB++; // Post-increment

  cout << "levelA: " << levelA << "\n";
  cout << "levelB: " << levelB;
}
```


```plain text
//<o>
levelA: 6
levelB: 6
```


## The Important Difference


The difference becomes apparent when you use them as part of a larger expression:


```c++
#include <iostream>

int main() {
  int level{5};

  // Level is incremented, then assigned
  int resultA{++level}; //<h>
  std::cout << "Using ++level:\n";
  std::cout << "level: " << level << "\n";
  std::cout << "resultA: " << resultA << "\n\n";

  level = 5; // Reset level

  // Level is assigned, then incremented
  int resultB{level++}; //<h>
  std::cout << "Using level++:\n";
  std::cout << "level: " << level << "\n";
  std::cout << "resultB: " << resultB;
}
```


```plain text
//<o>
Using ++level:
level: 6
resultA: 6

Using level++:
level: 6
resultB: 5
```


## When to Use Each


Use pre-increment (`++level`) when:

- You want the incremented value immediately in the same expression
- You're writing performance-critical code (pre-increment can be slightly faster)

Use post-increment (`level++`) when:

- You need the original value for something before incrementing
- You're implementing a counter that should increment after its current value is used

Here's a practical example using a game loop:


```c++
#include <iostream>
using namespace std;

int main() {
  int turnNumber{1};
  int maxTurns{3};

  while (turnNumber <= maxTurns) {
    cout << "Processing turn " //<h>
      << turnNumber++ << "\n"; //<h>
  }
}
```


```plain text
//<o>
Processing turn 1
Processing turn 2
Processing turn 3
```


In this example, we use post-increment because we want to display the current turn number before incrementing it for the next iteration.

Pre vs Post Increment

There are several ways to round floating-point numbers in C++, each with its own specific behavior. Let's explore the main approaches:


## Using Standard Library Functions


The `<cmath>` library provides several useful rounding functions:


```c++
#include <cmath>
#include <iostream>
using namespace std;

int main() {
  float damage{24.7f};

  // Round to nearest integer
  int roundedDamage{
    static_cast<int>(std::round(damage))};

  // Round down (floor)
  int floorDamage{
    static_cast<int>(std::floor(damage))};

  // Round up (ceiling)
  int ceilingDamage{
    static_cast<int>(std::ceil(damage))};

  cout << "Original: " << damage << "\n";
  cout << "Rounded: " << roundedDamage << "\n";
  cout << "Floor: " << floorDamage << "\n";
  cout << "Ceiling: " << ceilingDamage;
}
```


```plain text
//<o>
Original: 24.7
Rounded: 25
Floor: 24
Ceiling: 25
```


## Rounding to Decimal Places


Sometimes you want to round to a specific number of decimal places:


```c++
#include <cmath>
#include <iostream>
using namespace std;

float roundToDecimalPlaces(
  float value, int decimalPlaces
) {
  double multiplier{pow(10.0f, decimalPlaces)};
  return round(
    value * multiplier) / multiplier;
}

int main() {
  float health{95.6789f};

  // Round to various decimal places
  float oneDecimal{
    roundToDecimalPlaces(health, 1)};
  float twoDecimals{
    roundToDecimalPlaces(health, 2)};

  cout << "Original: " << health << "\n";
  cout << "One decimal place: "
    << oneDecimal << "\n";
  cout << "Two decimal places: "
    << twoDecimals;
}
```


```plain text
//<o>
Original: 95.6789
One decimal place: 95.7
Two decimal places: 95.68
```


## Practical Example: Damage Calculations


Here's a more practical example showing how rounding can be used in game mechanics:


```c++
#include <cmath>
#include <iostream>
using namespace std;

float calculateDamage(
  float baseDamage, float multiplier
) {
  float rawDamage{baseDamage * multiplier};

  // Round to nearest whole number
  return round(rawDamage);
}

int main() {
  float weaponDamage{10.0f};
  float criticalMultiplier{1.5f};

  float damage{
    calculateDamage(
      weaponDamage, criticalMultiplier)};
  cout << "Critical hit damage: "
    << damage << "\n";

  // Multiple calculations
  float multipliers[]{
    0.8f, 1.0f, 1.2f, 1.5f
  };
  cout <<
    "\nDamage with different multipliers:";
  for (float mult : multipliers) {
    cout << "\nMultiplier " << mult << ": "
      << calculateDamage(
        weaponDamage, mult);
  }
}
```


```plain text
//<o>
Critical hit damage: 15

Damage with different multipliers:
Multiplier 0.8: 8
Multiplier 1: 10
Multiplier 1.2: 12
Multiplier 1.5: 15
```

Rounding Floating Point Numbers

When you try to store a number that's too large for an integer type, you'll encounter what's called an "integer overflow". This behavior can be subtle and dangerous because C++ won't automatically prevent it or warn you about it.


## Understanding Integer Limits


First, let's see what the limits are for different integer types:


```c++
#include <iostream>
#include <limits>
using namespace std;

int main() {
  cout << "Maximum int value: "
    << numeric_limits<int>::max() << "\n";
  cout << "Minimum int value: "
    << numeric_limits<int>::min() << "\n";
  cout << "Maximum unsigned int value: "
    << numeric_limits<unsigned int>::max();
}
```


```plain text
//<o>
Maximum int value: 2147483647
Minimum int value: -2147483648
Maximum unsigned int value: 4294967295
```


## What Happens During Overflow


When overflow occurs, the number "wraps around". Here's what that looks like:


```c++
#include <iostream>
using namespace std;

int main() {
  int score{2147483647}; // Maximum int value
  cout << "Starting score: " << score;


  // Overflow occurs here
  score += 1; //<h>
  cout << "\nAfter adding 1: " << score;

  // Maximum unsigned int
  unsigned int playerCount{4294967295};
  cout << "\n\nStarting player count: "
    << playerCount;

  // Unsigned overflow
  playerCount += 1; //<h>
  cout << "\nAfter adding 1: " << playerCount;
}
```


```plain text
//<o>
Starting score: 2147483647
After adding 1: -2147483648
Starting player count: 4294967295
After adding 1: 0
```


## Preventing Overflow


Here's a safer way to handle potentially large numbers:


```c++
#include <iostream>
#include <limits>
using namespace std;

bool addScoreSafely(
  int& currentScore, int pointsToAdd) {
  // Check if addition would cause overflow
  if (pointsToAdd > 0 &&
    currentScore > numeric_limits<int>::max()
    - pointsToAdd) {
    cout << "Warning: Adding " << pointsToAdd
      << " would cause overflow!\n";
    return false;
  }

  // Check if subtraction would cause overflow
  if (pointsToAdd < 0 &&
    currentScore < numeric_limits<int>::min()
    - pointsToAdd) {
    cout << "Warning: Adding " << pointsToAdd
      << " would cause underflow!\n";
    return false;
  }

  currentScore += pointsToAdd;
  return true;
}

int main() {
  int score{2147483640};

  cout << "Current score: " << score << "\n";

  // Try to add 5 points
  if (addScoreSafely(score, 5)) {
    cout << "Successfully added 5 points. "
      "New score: " << score << "\n";
  }

  // Try to add 10 more points (would overflow)
  addScoreSafely(score, 10);
}
```


```plain text
//<o>
Current score: 2147483640
Successfully added 5 points. New score: 2147483645
Warning: Adding 10 would cause overflow!
```

Integer Overflow in C++

<Excerpt>


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:


```c++
bool isDead { false };
int Level { 5 };
float Armor { 0.2 };
int LargeNumber { 100000000 };
```


</Excerpt>


<Aside>


### Thousand Separators


When dealing with large numbers, it is often helpful to add separators to make them more readable for humans.  For example, we often add commas to a number like 100,000,000.


We can do something similar in our code if we want.  In C++, we can not use commas for this purpose - instead, we use the single quote character: `'`


```c++
int LargeNumber { 100'000'000 };
```


</Aside>


<Ad />


## 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:


```c++
// Level is initialized with a value of 5
int Level { 2 + 3 };

// It is then updated with the value of 10
Level = 5 * 2;
```


Here are some more examples:


```c++
// Level is initialized with a value of 5
int Level { 2 + 3 };

Level = 5 + 1; // Level is 6
Level = 5 - 1; // Level is 4
Level = 5 * 2; // Level is 10
Level = 6 / 2; // Level is 3
Level = 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:


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


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


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


## Variables with Maths


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


```c++
int StartingHealth { 500 };
int Lost { 100 };

// This will have a starting value of 400
int RemainingHealth { StartingHealth - Lost };
```


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


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


<Aside>


### The Assignment Operator (`=`)


A statement like `Level = Level + 1` may seem weird if we interpret it as an equation.


But in C++, and most programming languages, the `=` symbol is an _**operator**_.  It does not specify an equation - instead, like any operator, it acts upon its operands.  It updates the value of its left operand (`Level`, in this case) with the value of its right operand (`Level + 1`, in this case).


</Aside>


<Quiz title="Math with Variables">


<Question>


After running the following code, what will be the value of `Health`?


```c++
int BaseHealth { 200 };
int HealthBuff { 2 };
int Health { BaseHealth * HealthBuff };
```


<Answer isCorrect>
The integer `400`
<Feedback>


Correct! Multiplying `BaseHealth` (200) by `HealthBuff` (2) results in `400`,


</Feedback>


</Answer>


<Answer>


The integer `500`


<Feedback>


Incorrect. `BaseHealth` multiplied by `HealthBuff` does not equal 500. Remember to multiply the values of the variables.


</Feedback>


</Answer>


<Answer>


The integer `600`


<Feedback>


Incorrect. When you multiply `BaseHealth` (200) by `HealthBuff` (2), the result is not 600.


</Feedback>


</Answer>


<Answer>


This is invalid code


<Feedback>


This code is valid. The multiplication operation is correctly applied to two integer variables.


</Feedback>


</Answer>


</Question>


<Question>


After running the following code, what will be the value of `Level`?


```c++
int Level { 10 };
int Level = Level + 1;
```


<Answer>
The integer `9`
<Feedback>


Incorrect.  Walk through the code step by step and try to understand what it is doing


</Feedback>


</Answer>


<Answer>


The integer `10`


<Feedback>


Incorrect. This is the original value of `Level`, but what is the second line doing?


</Feedback>


</Answer>


<Answer>


The integer `11`


<Feedback>


Incorrect. Is the second line updating a variable, or creating a new one?


</Feedback>


</Answer>


<Answer isCorrect>


This is invalid code


<Feedback>


Correct!  Remember, we only specify the variable type when we first create it.  When we want to access the value stored in a variable already created, we just identify it by name.


The following code would have been valid, and left `Level` with a value of `11`:


```c++
//<qa>
int Level { 10 };
Level = Level + 1;
```


</Feedback>


</Answer>


</Question>


</Quiz>


## 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, but for now we can use them interchangeably:


```c++
int Level { 5 };
Level++;  // Level is now 6
++Level;  // Level is now 7
```


We also have the `--` operator for decrementing:


```c++
int Level { 5 };
Level--;  // Level is now 4
--Level;  // Level is now 3
```


## Compound Assignment


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.


```c++
int Level { 5 };
Level += 3;  // Level is now 8
```


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


```c++
int Level {8};
Level -= 3; // Level is now 5
Level *= 3;  // Level is now 15
Level /= 5; // Level is now 3

Level *= Level; // Level is now 9
```


<Quiz title="Shorthand Operators">


<Question>


After running the following code, what will be the value of `Level`?


```c++
int Level { 2 };
Level = Level * Level + 2;
Level -= 2;
```


<Answer>
The integer `2`
<Feedback>


This is not the correct result. Think about how the value of `Level` changes with each operation. Start with the initial value and apply each operation step by step.


</Feedback>


</Answer>


<Answer isCorrect>


The integer `4`


<Feedback>


Correct! Initially, `Level` is `2`. Then `Level` becomes `2 * 2 + 2`, which is `6`. Finally, `Level -= 2` changes it to `4`.


</Feedback>


</Answer>


<Answer>


The integer `6`


<Feedback>


Consider how the subtraction in the last line affects the value of `Level`. Remember that the operations are performed in sequence, so the final result might not be the same as the intermediate value.


</Feedback>


</Answer>


<Answer>


This is invalid code


<Feedback>


The code is valid. Focus on the arithmetic operations being performed on `Level`. Break down the code line by line and calculate the result of each operation.


</Feedback>


</Answer>


</Question>


</Quiz>


## Negative Numbers


We have access to negative numbers using the `-` symbol:


```c++
int NegativeValue { -5 };
```


They behave exactly like they would in maths


```c++
int Health { 100 };
int HealthModifier { -10 };

Health += HealthModifier; // Health is now 90

Health *= -1; // Health is now -90
```


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


<Definition>


### Binary and Unary Operators


C++ operators can be either _**binary**_ or _**unary**_.  A binary operator such as `<<` or `=`  has **two** operands: one on the left, and one on the right.  In the following example, `Health` is the left operand, and `100` is the right operand:


```c++
Health = 100;
```


Unary operators such as `++` have a single operand.  In the following example, the operand is `Level`:


```c++
++Level;
```


Some syntax, such as `-`, can represent either a binary or unary operator.  It's generally clear which one is being used based on the surrounding code:


```c++
// The binary -
100 - 50;

// The unary -
-50;
```


</Definition>


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 `-`:


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


## Integer Division


What would the result be of dividing `5` by `2`?


```c++
#include <iostream>
using namespace std;

int main(){
  cout << "5 / 2 = " << 5 / 2;
}
```


Perhaps surprisingly, C++ says it is `2`:


```c++
//<o>
5 / 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:


```c++
// IntegerLevel is 2
int IntegerLevel { 5/2 };

// FloatingLevel is 2.0
float FloatingLevel { 5/2 };
```


Even when 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`.


<Quiz title="Integer Division">


<Question>


After running the following code, what will be the value of `Level`?


```c++
int Level { 3 / 2 };
```


<Answer isCorrect>
The integer `1`
<Feedback>
Correct! Integer division truncates the decimal part, so **`3 / 2`** results in **`1`**, not **`1.5`**.


</Feedback>


</Answer>


<Answer>


The floating point number `1.5`


<Feedback>


Incorrect. In C++, integer division results in an integer without the decimal part. So, `3 / 2` is `1`, not `1.5`.


</Feedback>


</Answer>


<Answer>


The integer `2`


<Feedback>


Incorrect. Integer division of **`3 / 2`** yields **`1`**, as the decimal part is truncated, not rounded up.


</Feedback>


</Answer>


<Answer>


This is invalid code


<Feedback>


Incorrect. This code is valid


</Feedback>


</Answer>


</Question>


<Question>


After running the following code, what will be the value of `Level`?


```c++
float Level { 1 / 2 };
```


<Answer isCorrect>
The floating point number `0.0`
<Feedback>


Correct! Despite `Level` being a float, `1 / 2` is integer division and results in `0`, which is then implicitly converted to `0.0`.


</Feedback>


</Answer>


<Answer>


The integer `0`


<Feedback>


Incorrect. While `1 / 2` results in the integer `0`, it is assigned to the variable `Level`, which is not an integer.


</Feedback>


</Answer>


<Answer>


The floating point number `0.5`


<Feedback>


Incorrect. Since both **`1`** and **`2`** are integers, the division results an in integer (`0`), which is then converted to a float (`0.0`).


</Feedback>


</Answer>


</Question>


</Quiz>


## Floating Point Numbers


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`:


```c++
cout << 5.0/2;
cout << 5/2.0;
cout << 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:


```c++
5 + 1.0; // 6.0
5.0 + 1; // 6.0

5 - 1.0; // 4.0
5.0 - 1; // 4.0

5 * 2.0; // 10.0
5.0 * 2; // 10.0

5.0 / 2; // 2.5
5 / 2.0; // 2.5
```


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


```c++
float Health { 2.5 };
```


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


```c++
float 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:


```c++
// MaxHealth is 2.5
float MaxHealth { 5.0 / 2.0 };

// CurrentHealth is 2.5
float 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`


```c++
float Health { 5/2 }; // Health is 2.0
```


<Ad />


## Floating Point Operations


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


```c++
float Health { 5.0 }; // Health is 5.0
Health = Health + 20.0; // Health is now 25.0
Health++; // Health is now 26.0
Health--; // Health is now 25.0

// We can freely combine floating and
// integer numbers in the expressions
Health += 25; // Health is now 50.0
Health -= 10; // Health is now 40.0
Health *= 2.5; // Health is now 100.0
Health /= 3; // Health is now 33.3333...
```


<Preview>


### Float Literals


In other learning resources, you may see `float` variables used with an `f` suffix, as in `3.14f`.   For example, the following two variable initializations are equivalent:


```c++
float VariableA { 3.14 };
float VariableB { 3.14f }; //<h>
```


We'll revisit this topic later in the chapter and cover it in a bit more detail.  However, to keep things as simple as possible, we won't append the `f` to our floating point numbers in this course, unless doing so makes a difference.  In the situations where it does matter, we'll explain why.


</Preview>


<Aside>


### The Floating Component is Optional


Often, we will be using floating point numbers that are initially "round", eg, `4.0` and `5.0`.


Where the floating component is `0`, it can be removed entirely.  This is shown below, where both variables will have the value `4.0`:


```c++
float VariableA { 4. };
float VariableB { 4.f };
```


We don't do this in our code samples, but it's worth noting, as this often causes some confusion when looking at other people's code.


</Aside>


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

<Preview>


### Boolean Variables


In our next lesson, we'll shift our focus to another fundamental aspect of programming: Boolean variables. This upcoming lesson 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.

</Preview>

Published FAQs and moved sections on alternative numeric types to a later lesson

Fixed error where summary section was referencing content that had been moved to a later lesson

Expanded explanation of the unary `-` operator

C++ Language

Free Maths Courses

C++ Reference

Introduction to Computer Science

{CPP}Beginner's guide to numeric variables in C++. Understand how to manipulate numbers using arithmetic operators and more

Numbers

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Intro to C++ Programming

Questions & Answers