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

Even though modern computers have lots of memory, being efficient with memory usage is still important for several reasons:


First, your program isn't running alone. Modern computers might be running dozens or even hundreds of programs at once. If every program wastes memory, it adds up quickly. Think of it like sharing a pizza - if everyone takes more slices than they need, some people might not get any!


Second, some programs need to handle huge amounts of data. Imagine a game that needs to track thousands of monsters, each with their own stats. If we waste even a small amount of memory per monster, it can add up to a lot of wasted space:


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

int main() {
  // Using too much memory per monster
  int64_t Health{100};  // 8 bytes
  int64_t Level{1};     // 8 bytes
  // Total: 16 bytes per monster

  // Using appropriate sized types
  int16_t BetterHealth{100};  // 2 bytes
  int8_t BetterLevel{1};      // 1 byte
  // Total: 3 bytes per monster

  int NumberOfMonsters{10000};

  cout << "Wasteful approach uses: "
    << NumberOfMonsters * 16 << " bytes\n";
  cout << "Efficient approach uses: "
    << NumberOfMonsters * 3 << " bytes\n";
}
```


```c++
//<o>
Wasteful approach uses: 160000 bytes
Efficient approach uses: 30000 bytes
```


Third, some devices (like phones or game consoles) have limited memory. If you want your program to work well on these devices, you need to be careful with memory.


Finally, using more memory than necessary can make your program slower. When your program uses memory, the computer needs to manage that memory - allocating it, tracking it, and cleaning it up. The more memory you use, the more work the computer has to do.


Think of memory usage like packing for a trip - even if you have a huge suitcase, it's still better to pack efficiently. It makes everything easier to manage, and leaves room for when you really need it!

Memory Usage in Modern Computers

Computers use something called ASCII (American Standard Code for Information Interchange) to convert letters into numbers, which can then be stored as bits. Think of it like a secret code where each letter is assigned a specific number.


For example, in ASCII:

- The letter 'A' is represented by the number 65
- The letter 'B' is represented by 66
- The letter 'a' is represented by 97
- The letter 'b' is represented by 98

Here's a program that shows this in action:


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

int main() {
  char Letter{'A'};
  cout << "The letter " << Letter
    << " is stored as number: "
    << static_cast<int>(Letter) << '\n';

  char NextLetter{'B'};
  cout << "The letter " << NextLetter
    << " is stored as number: "
    << static_cast<int>(NextLetter) << '\n';

  // We can also go backwards - storing
  // a number creates a letter
  char LetterFromNumber{97}; // This creates 'a'
  cout << "The number 97 represents the letter: "
    << LetterFromNumber << '\n';
}
```


```c++
//<o>
The letter A is stored as number: 65
The letter B is stored as number: 66
The number 97 represents the letter: a
```


Once we have these numbers, we can convert them to bits. For example, the letter 'A' (65 in decimal) is `01000001` in binary. Each character typically uses one byte (8 bits) of memory.


This system works for more than just letters. ASCII includes codes for numbers, punctuation marks, and special characters. For example:

- The space character is 32
- The exclamation mark (!) is 33
- The number character '0' is 48

Modern computers often use more advanced systems like UTF-8 (which can represent characters from many different languages), but the basic idea is the same - convert characters to numbers, then store those numbers as bits.

How Computers Store Text

While you can't check memory usage directly from within C++, there are several tools and techniques you can use to monitor how much memory your program is using.


## Task Manager (Windows)


The simplest way on Windows is to use Task Manager:

1. Run your program
2. Press Ctrl+Shift+Esc to open Task Manager
3. Look for your program in the list
4. Check the "Memory" column

## Activity Monitor (Mac)


On Mac, you can use Activity Monitor:

1. Open Activity Monitor from Applications > Utilities
2. Look for your program
3. Check the "Memory" column

## Visual Studio Memory Usage Tool


If you're using Visual Studio:

1. Run your program in debug mode (F5)
2. Open Debug > Windows > Memory Usage
3. This shows detailed information about memory usage

Here's a simple program that uses different amounts of memory. Try running it and watching the memory usage in Task Manager:


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

int main() {
  cout << "Press Enter to continue each"
    " step...\n\n";

  string input;
  getline(cin, input);

  // Create some variables that use memory
  int32_t Numbers[10000];
  cout << "Created array of 10000 integers\n";

  getline(cin, input);

  // Create more variables
  int32_t MoreNumbers[100000];
  cout << "Created array of 100000 integers\n";

  getline(cin, input);

  cout << "Program ending...";
}
```


The program pauses between allocations so you can watch the memory usage increase in Task Manager. Remember that the total memory used will be more than just our variables - the program itself needs some memory to run!


While these tools can help you track memory usage, the best way to manage memory is to think about it while writing your code. Use appropriate types for your data, and avoid creating unnecessary variables or really large arrays unless you need them.

Monitoring Program Memory Usage

There are several common scenarios where using smaller integer types makes sense. Here are some practical examples:


## Games and Graphics


In games, you often need to store information for lots of objects. For example, if you're making a role-playing game, you might have stats for each character:


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

int main() {
  // Using regular int for everything (wasteful)
  int Health{100};       // 4 bytes
  int Level{1};          // 4 bytes
  int Strength{15};      // 4 bytes
  int Intelligence{12};  // 4 bytes
  // Total: 16 bytes per character

  // Using appropriate sizes
  // 2 bytes (max 32,767 is plenty)
  int16_t BetterHealth{100};
  // 1 byte (max 127 is enough)
  int8_t BetterLevel{1};      
  // 1 byte (max 127 is enough)
  int8_t BetterStrength{15};
  // 1 byte (max 127 is enough)
  int8_t BetterIntelligence{12};
  // Total: 5 bytes per character

  // If your game has 1000 characters, you save:
  cout << "Memory saved per 1000 characters: "
    << (16 - 5) * 1000 << " bytes";
}
```


```c++
//<o>
Memory saved per 1000 characters: 11000 bytes
```


## Color Information


In graphics programming, colors are often stored as RGB values from 0-255, making `uint8_t` perfect:


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

int main() {
  // Each color component only needs
  // values 0-255
  uint8_t Red{255};  // Perfect fit!
  uint8_t Green{128};
  uint8_t Blue{64};

  // Using regular int would waste 3 bytes
  // per color component!
  // Uses 4 bytes instead of 1
  int WastefulRed{255};
  int WastefulGreen{128};
  int WastefulBlue{64};

  cout << "Memory used for one color"
          " (efficient): "
    << sizeof(Red) + sizeof(Green) + sizeof(Blue)
    << " bytes\n";

  cout << "Memory used for one color"
    " (wasteful): "
   << sizeof(WastefulRed)
    + sizeof(WastefulGreen)
    + sizeof(WastefulBlue)
   << " bytes";
}
```


```c++
//<o>
Memory used for one color (efficient): 3 bytes
Memory used for one color (wasteful): 12 bytes
```


## Embedded Systems


When programming small devices (like Arduino), memory is very limited. Using smaller types can be the difference between your program fitting in memory or not!


Remember though - don't use smaller types just because you can. Only use them when you:

- Know the maximum value you need to store
- Have tested to make sure the smaller type won't cause problems
- Are working with large amounts of data where the savings matter
- Are working on a memory-constrained system

Most of the time, using regular `int` is fine and makes your code simpler and safer.

When to Use Small Integer Types

While unsigned integers can be tricky to work with, they do have legitimate uses. Here are some real-world scenarios where unsigned integers make sense:


## Array Sizes and Counts


When you're counting things or working with sizes, the number can never be negative. For example, you can't have -3 players in a game. However, we typically still use regular integers for these because the benefits rarely outweigh the risks.


## Hardware and Low-Level Programming


When working directly with computer hardware, unsigned integers are often required because they map directly to how the hardware works. For example, memory addresses are always positive numbers.


## Binary Data and File Sizes


When working with file sizes or network data, unsigned integers are commonly used because these values are never negative:


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

int main() {
  // File sizes are never negative
  uint64_t VideoFileSize{1'500'000'000};

  // Data amounts are never negative
  uint32_t BytesDownloaded{750'000};

  cout << "Downloading " << BytesDownloaded
    << " bytes out of " << VideoFileSize;

  // This would make no sense - a file
  // can't be -1000 bytes!
  int NegativeFileSize{-1'000};  
}
```


```c++
//<o>
Downloading 750000 bytes out of 1500000000
```


## Bitwise Operations


When doing binary operations (working directly with bits), unsigned integers are often preferred because they have well-defined behavior:


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

int main() {
  // Using binary literal
  uint8_t Flags{0b00000101};

  // Each bit can represent a yes/no setting
  // First bit
  bool IsHappy = (Flags & 0b00000001) != 0;

    // Third bit
  bool IsFlying = (Flags & 0b00000100) != 0;

  cout << "Character is happy: " << IsHappy
    << "\nCharacter is flying: " << IsFlying;
}
```


```c++
//<o>
Character is happy: 1
Character is flying: 1
```


However, unless you're doing one of these specialized tasks, it's usually better to use regular signed integers. They're safer because:

- You can't accidentally go below zero
- They work more intuitively with subtraction
- They cause fewer surprises when mixed with regular integers
- Most C++ standard library functions expect signed integers

The general rule is: use signed integers by default, and only use unsigned integers when you have a specific reason to do so and understand the implications.

Uses for Unsigned Integers

Preventing overflow is important, especially in programs where accuracy is crucial. Here are some ways to check for potential overflow before it happens:


## Check Against Type Limits


C++ provides constants that tell us the maximum and minimum values for each number type. We can check against these before doing calculations:


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

int main() {
  int PlayerGold{2'000'000'000};  // 2 billion
  int GoldToAdd{500'000'000};     // 500 million

  // Check if adding would exceed the maximum
  if (PlayerGold >
    numeric_limits<int>::max() - GoldToAdd) {
    cout << "Warning: Adding this much gold"
      " would overflow!\n";
  } else {
    PlayerGold += GoldToAdd;
    cout << "New gold amount: "
      << PlayerGold << '\n';
  }

  // Let's try with a smaller amount
  GoldToAdd = 100'000'000;  // 100 million

  if (PlayerGold >
    numeric_limits<int>::max() - GoldToAdd) {
    cout << "Warning: Adding this much gold"
      " would overflow!\n";
  } else {
    PlayerGold += GoldToAdd;
    cout << "New gold amount: " << PlayerGold;
  }
}
```


```c++
//<o>
Warning: Adding this much gold would overflow!
New gold amount: 2100000000
```


## Use Bigger Types When Needed


If you're working with values that might get very large, use a bigger type from the start:


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

int main() {
  // This might overflow:
  int32_t Score{2'000'000'000};
  Score *= 2;  //<w>
  cout << "Score (might overflow): " << Score;

  // This is safe:
  int64_t BigScore{2'000'000'000};
  BigScore *= 2;
  cout << "\nBigScore (safe): " << BigScore;
}
```


```c++
//<o>
Score (might overflow): -294967296
BigScore (safe): 4000000000
```


## Set Reasonable Limits


Often, the best approach is to set reasonable limits on your values:


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

int main() {
  int PlayerHealth{100};
  int HealthPotion{50};
  int MaxHealth{100};

  // Check if healing would exceed max health
  if (PlayerHealth + HealthPotion > MaxHealth) {
    PlayerHealth = MaxHealth;
    cout << "Health restored to maximum: "
      << PlayerHealth << '\n';
  } else {
    PlayerHealth += HealthPotion;
    cout << "Health increased to: "
      << PlayerHealth;
  }
}
```


```c++
//<o>
Health restored to maximum: 100
```


Remember:

- Always check for overflow when working with critical calculations
- Use appropriate type sizes for your data
- Set reasonable limits where possible
- Consider using larger types if you need to work with very large numbers
- When in doubt, test with extreme values to make sure your program handles them correctly

Preventing Number Overflow

You can control how floating point numbers are displayed using various formatting options in C++. Here are some common approaches:


## Using `precision()`


The simplest way is to set how many decimal places to show using `precision()`:


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

int main() {
  float Pi{3.14159265359};

  // Default output
  cout << "Default Pi: " << Pi << '\n';

  // Set to 2 decimal places
  cout.precision(2);//<h>
  cout << "Pi with 2 digits: " << Pi << '\n';

  // Set to 4 decimal places
  cout.precision(4);//<h>
  cout << "Pi with 4 digits: " << Pi;
}
```


```c++
//<o>
Default Pi: 3.14159
Pi with 2 digits: 3.1
Pi with 4 digits: 3.142
```


## Using `fixed`


Sometimes we want to always show a specific number of decimal places, even if they're zeros. We can use `fixed` for this:


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

int main() {
  float Price{19.99};
  float WholeNumber{20.0};

  // Set to show exactly 2 decimal places
  cout.precision(2);
  cout << fixed;//<h>

  cout << "Price: $" << Price;
  cout << "\nWhole number: $" << WholeNumber;

  // You can turn off fixed mode if needed
  cout.unsetf(ios::fixed);
  cout << "\nBack to default: " << Price;
}
```


```c++
//<o>
Price: $19.99
Whole number: $20.00
Back to default: 20
```


## Using `showpoint`


If you want to always show the decimal point, even for whole numbers, use `showpoint`:


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

int main() {
  float Score{100.0};

  // Default - no decimal for whole numbers
  cout << "Score: " << Score << '\n';

  // Force showing decimal point
  cout << showpoint;//<h>
  cout << "Score with decimal: " << Score;
}
```


```c++
//<o>
Score: 100
Score with decimal: 100.000
```


Remember:

- These settings stay in effect until you change them
- Different settings might make sense for different situations (like showing exactly 2 decimal places for money)
- Be consistent in how you display numbers in your program
- When working with money, remember that floating point numbers can have small rounding errors, so you might want to store cents as integers instead

Controlling Decimal Places

<Excerpt>


Programming languages are often arranged on a spectrum from "high-level" or "low-level". Higher level languages (like Python) focus on making it easy for humans to write code, hiding many technical details about how computers work.


Lower level languages give programmers more direct control over the computer's hardware and memory, which can make programs faster and more efficient.


C++ is considered a relatively low-level language, which means we sometimes need to understand what's happening "under the hood" when we write our code. This is particularly true when it comes to how our programs use computer memory.


</Excerpt>


<Aside>


### Optional Lesson


This lesson is a little more advanced and theoretical.  It discusses what's going on behind the scenes when we create variables, and explains why there are alternatives to types like `int` and `float`.


It can be useful to know that alternatives exist, and why they exist, particularly if you're using this course in conjunction with other learning material.


However, it's not entirely necessary at this stage.  We'll stick with `int` and `float` for the rest of this beginner course, so feel free to move on from this lesson if it's not interesting or helpful, or doesn't entirely make sense.


</Aside>


## Memory


When we create variables in C++, we're requesting the operating system give us a block of memory we can store our data in.  The variable name lets us return to that memory location later, and retrieve or modify the value stored there.


Memory is made up of a series of **bits** (short for "binary digit").  A bit is the smallest unit of data in computing.  It can have one of only two possible values, which we usually represent by `0` and `1`.


By combining multiple bits, we can represent more and more complex data.  Two bits can have four possible configurations (`00`, `10`, `01`, or `11`).  Three bits can have 8, four can have 16 and, in general, each additional bit doubles the number of distinct values that can be represented.


A **byte** is a combination of 8 bits, for example, `01001110` or `10101001`.  There are 256 different possible configurations for 8 bits.  Therefore, a byte can store one of 256 possible values.


Those values could represent anything we want - for example:

- an integer from 0-255
- one of 256 different alphabetic characters
- a color from a palette of 256 options

When we create a variable in C++, the _**type**_ of that variable determines how many bits of memory are allocated to it, and how those bits are used.


So far, we've just been using the simple `int` data type for storing our integers, but there are other options.


## Integer Width


One reason we have different types to store integers is to control how much memory we want to allocate for our number.


For example, if we wanted to store a variable representing the level of a monster, and our maximum `Level` is 50, we don't need to allocate a huge amount of memory for that variable. 8 bits of memory would be enough - that would allow for 256 possible values in that space.  Half of that range is assigned to negative numbers, so 8-bit integers can typically range from -128 to 127


The amount of space a type uses in memory is sometimes called its _**width**_.  For example, a type that uses 8 bits of memory has a _**width**_ of 8 bits.  To create an integer that uses only 8 bits of memory, we can use the `int8_t` type: 


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

int main() {
  int8_t Level{50};
}
```


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


Just as we can use `int8_t` to store small integers, similar types exist for 16, 32, and 64 bit integers:


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

int main() {
  int8_t SmallNumber{100};
  int16_t MediumNumber{10'000};
  int32_t LargeNumber{1'000'000'000};
  int64_t HugeNumber{1'000'000'000'000'000'000};
}
```


### Fixed-Width Integers


Types like `int32_t` are typically referred to as "fixed-width integers", as their width is guaranteed to be the same across all platforms.  The basic `int` type is _**not**_ fixed width.  The C++ specification states it should be at least 16 bits but it can be larger and, on most modern platforms, it is.


C++ includes other named integer types with non-fixed width, such as `short` (typically smaller than an `int`) and `long` (typically larger than an `int`):


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

int main() {
  short SmallNumber{100};
  int MediumNumber{10'000};
  long LargeNumber{1'000'000'000};
}
```


This is all quite messy, so most developers and teams settle on a convention on which types should (and should not) be used.  For integers, a common convention is:

- Use the basic `int` type, unless we have a specific reason to intervene in the size
- If we do need to control the size, use an appropriate fixed-width type like `int8_t`

Conventions like these are normally documented in an organization's _**style guide**_, which specifies how code should be written within that company.  Some organizations, such as Google, also publish their style guide:


<Quote author="Google C++ Style Guide" url="[https://google.github.io/styleguide/cppguide.html#Integer_Types](https://google.github.io/styleguide/cppguide.html#Integer_Types)">


Of the built-in C++ integer types, the only one used is `int`. If a program needs an integer type of a different size, use an exact-width integer type such as `int16_t`


</Quote>


## Overflows


Now that we know that every numeric type has a maximum and minimum value it can store, what happens when we go beyond those limits?  When we try to store a number outside these limits, we get what's called an _**overflow**_.


Think of it like an odometer in a car - when it reaches its maximum value and you drive further, it wraps back to zero. Numbers in C++ behave similarly:

- If we go above the maximum value, the number wraps around to the minimum value
- If we go below the minimum value, the number wraps around to the maximum value

Here's an example using an `int` which, assuming it uses 32 bits, can hold a maximum value of around 2.1 billion.  We initialize it with a value of 2 billion, which is in the valid range.  However, when we add another billion, it goes beyond what the type can store:


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

int main() {
  int Number{2'000'000'000};
  Number += 1'000'000'000;//<w>
  cout << Number;
}
```


The value stored in our variable wraps around to the other side of its range, resulting in a negative value in this case:


```c++
//<o>
-1294967296
```


This is generally going to result in a bug, so we should be sure the width of our variable is sufficient to accommodate the range of values we expect that variable to store.


## Signed and Unsigned Integers


The main way we prevent overflows is simply to increase the width of the variable to ensure it can store a wider range of possibilities.  We might switch it from an `int` to an `int64_t` for example. 


However, if the variable we're creating is never intended to be negative, we have another option to increase it's maximum value.  We could eliminate the negative numbers from its range of possibilities, leaving more room for larger positive values.  This is the idea behind _**unsigned**_ integers.


In almost all cases, this is not recommended - using a larger type is a better approach for reasons we'll cover in the next section.  However, we should understand that unsigned integers exist, so let's cover them briefly.


### Signed Integers


We saw how 8 bits of memory can store 256 different possible values.  But what range of integers should we map to those options?


Most integer types are _**signed**_, meaning they can store negative values.  If we map our 256 possibilities to a range that includes the same quantity of negative and non-negative numbers, an 8-bit signed integer can store values in the range of -128 to 127:


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

int main() {
  // These are fine
  int8_t NegativeNumber{-100};
  int8_t PositiveNumber{100};

  // Error: This is out of range
  int8_t LargerNumber{200}; //<e>
}
```


```c++
//<oe>
error C2397: conversion from 'int' to 'int8_t' requires a narrowing conversion
```


### Unsigned Integers


An _**unsigned**_ integer cannot be negative, so it allows us to map those 256 possibilities to a range that only includes non-negative numbers.  As such, an 8-bit unsigned integer can store values in the range 0 - 255.


The unsigned variation of  `int8_t` is available by prepending `u`, as in `uint8_t`:


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

int main() {
  // Error: This is out of range
  uint8_t NegativeNumber{-100}; //<e>

  // These are fine
  uint8_t PositiveNumber{100};
  uint8_t LargerNumber{200};
}
```


```c++
//<oe>
error C2397: conversion from 'int' to 'uint8_t' requires a narrowing conversion
```


Similarly, we have `uint16_t`, `uint32_t`, and `uint64_t`.  An unsigned form of the basic `int` type is also available, called `unsigned int`:


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

int main() {
  uint8_t SmallNumber{100};
  uint16_t MediumNumber{10'000};
  uint32_t LargeNumber{1'000'000'000};
  uint64_t HugeNumber{1'000'000'000'000'000'000};
  
  unsigned int BasicUnsignedInt{10,000};
}
```


### Why Unsigned Integers are Problematic


Unless we're creating software for an environment that is extremely memory-constrained, using unsigned integers for memory optimization is an unnecessary and risky choice. 


The first problem with unsigned integers is that their lower limit is `0` and, in most real-world scenarios, the values we work with are quite close to `0`.  This means that we're much more likely to accidentally introduce overflow-related bugs when we're using unsigned types:


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

int main() {
  unsigned int Health { 0 };
  Health -= 1; //<w>
  cout << Health;
}
```


```c++
//<o>
4294967295
```


Worse, the interaction between signed and unsigned integers can be unpredictable.  C++ compilers will convert signed integers to unsigned integers in situations we wouldn't intuitively expect, which can create unintended behaviors.


In the following example, to compare our signed and unsigned integers, the compiler is converting `-1` to an unsigned value.  `-1` is outside the valid range of an unsigned integer, so it wraps around to a huge positive number:


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

int main() {
  int Signed{-1};
  unsigned int Unsigned{1};

  if (Signed > Unsigned) {  // true//<w>
    cout << Signed << " is greater than "
      << Unsigned << "?";
  }
}
```


That huge positive number is indeed greater than `1`, so we get the unintuitive output:


```c++
//<o>
-1 is greater than 1?
```


Because of these problems, when we need to support larger numbers than our type allows, it's almost always better to simply use a type of larger size rather than switching to an unsigned type.


This could mean, for example, switching from an `int16_t` to an `int32_t`, or from an `int` to an `int64_t`.


<Aside>


### Compiler Warnings


Whilst the previous example is valid C++ code and compilers will implement it in accordance with the C++ rules, they will likely also detect that our code is doing something unusual.


To help us with scenarios like this, compilers will typically output _**warnings**_.  Warnings will not prevent our code from compiling - their purpose is to alert us that the compiler found something in our code that may require our attention.


IDEs will generally place compiler warnings somewhere on our screen after our build has completed.  In Visual Studio, these are available in the _**Error List**_ window which is included in the default UI, or can be opened from the _**View**_ menu.


<Img file="compiler-warnings-signed.png" width="509" height="207" alt="Screenshot of Visual Studio outputting compiler warnings" blurHash="L36Hy9%LRiX8^,ocockW4oM{t7oz" />


</Aside>


## Floating Point Width


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 implemented slightly differently in terms of how they use their available memory.


What changes when we give floating point numbers more memory is both their _**precision**_ (significant digits) and range (magnitude of values they can represent).


The most common data types for floating point numbers are `float` and `double`. 


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

int main() {
  float A{3.14};
  double B{9.8};
}
```


As with basic integers, the C++ specification doesn't specify how many bits should be allocated but, in practice, it's usually 32 bits for a `float` and 64 bits for a `double`.  This means a `double` is more precise than a `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 following program shows an example of this, where arithmetic using `double`s gives more accurate outputs than the same expression using `float`s.


Note that, by default, `cout` will round floating point numbers to 6 significant figures when outputting them to the terminal.  We can increase this to a higher value, such as 16, using `cout.precision(16)`:


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

int main() {
  // Cause cout to show more decimal places
  // when outputting floating point numbers
  cout.precision(16);

  float A { 1.1111111111111111 };
  cout << "Float Precision:  "
    << A + A << '\n';

  double B { 1.1111111111111111 };
  cout << "Double Precision: "
    << B + B;
}
```


```c++
//<o>
Float Precision:  2.222222328186035
Double Precision: 2.222222222222222
```


The basic `float` will be sufficient for our needs in this course. 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 compiler can infer the type of literal we're creating based on the exact syntax we use.  For example,

- `6` is an `int` literal
- `true` and `false` are `bool` literals
- `4.0` is a `double` literal
- `4.0f` (note the `f` suffix) is a `float` literal
- `'a'` (straight single quotes) is a `char` literal - a single character
- `"Goblin Warrior"` (straight double quotes) is a `char*` literal.  A `char*` is one of many ways to represent strings of characters.  We'll explain what the `*` represents later in this course, and we cover string representations more generally in the advanced course.
- `"Goblin Warrior"s` (straight double quotes and `s` suffix) is a standard `string` literal, also known as a `std::string` literal.  We'll cover the meaning of the `std::` syntax later in the course.

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:


```c++
// Creating a float from a double literal
float MyNumber { 4.0 };

// Creating a string from a char* literal
string 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:


```c++
float MyNumber { 4.0f };
string MyString { "Goblin Warrior"s };
```


Feel free to include these suffixes if you feel more comfortable.  To make our code samples as simple as possible for beginners, we will not include them in this course, except in the rare scenarios where doing so is impactful to the program's behavior.  In those situations, we will point it out and explain why.


## Summary


In this lesson, we explored how C++ manages computer memory and different ways to store numbers. Here are the key points to remember:

- Computer memory is made up of bits, with 8 bits forming a byte
- Different number types (like `int8_t`, `int16_t`, etc.) use different amounts of memory
- Using more memory allows us to store bigger numbers or more precise decimal values
- Unsigned integers can only store positive numbers and zero
- It's usually better to use signed integers and increase their size if needed
- When numbers exceed their type's range, they "overflow" and wrap around
- Floating point numbers come in different precisions (`float` vs `double`)
- Literals are fixed values in our code and have specific types

<Preview>


### Debugging


In our upcoming lesson, we'll introduce an essential tool for every programmer: the debugger. Here's a sneak peek of what you'll learn:

- **Introduction to Debugging**: Discover what a debugger is and why it's a critical tool in programming.
- **Using the Debugger in C++**: Learn how to use the debugger to step through your C++ code, inspect variables, and understand the flow of your program.
- **Debugging Techniques**: Gain insights into various techniques that help identify and fix errors in your code.

</Preview>

Fixed typo in Signed and Unsigned Integers section

Removed a `std::` qualification in explanation of `std::cout`'s rounding of floats

Abstract art representing computer programming

Fundamental types

Fixed width integer types

Integer literal

Floating-point literal

Fixed-point and floating-point number representations

Fundamental types (C++)

Floating-Point Operations

C++ Style Guide - Integer Types

{CPP}Understand how C++ programs store and manage numbers. Learn about different numeric types, memory allocation, and how to prevent common programming errors

Types and Literals

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Intro to C++ Programming

Questions & Answers