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

Yes! The easiest way to check how a value will be converted is to create a small test program. Let's look at how to do this safely:


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

int main() {
  // Store the original value in a variable
  double Original{3.7};

  // Then create new variable of the target type
  int Converted{static_cast<int>(Original)};

  // Print both to see the difference
  cout << "Original value: " << Original;
  cout << "\nConverted value: " << Converted;
}
```


```plain text
//<o>
Original value: 3.7
Converted value: 3
```


We can do the same thing with other types too. Here's how different number types convert to `bool`:


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

int main() {
  int Zero{0};
  int One{1};
  int FortyTwo{42};

  bool FromZero{static_cast<bool>(Zero)};
  bool FromOne{static_cast<bool>(One)};
  bool FromFortyTwo{static_cast<bool>(FortyTwo)};

  // Makes cout show "true"/"false"
  cout << std::boolalpha;
  cout << "0 converts to: " << FromZero << "\n";
  cout << "1 converts to: " << FromOne << "\n";
  cout << "42 converts to: " << FromFortyTwo;
}
```


```plain text
//<o>
0 converts to: false
1 converts to: true
42 converts to: true
```


Notice we used `static_cast<>()` in these examples. This is the safe way to do conversions in C++. While implicit conversions will work too, using `static_cast<>()` makes it clear to other programmers (and yourself!) that you intended to do the conversion.


Remember that some conversions might lose data (like when converting from `double` to `int`), so it's always good to test your conversions with realistic values before using them in your actual program.

Testing Type Conversions

When you try to convert a number that's too big for its destination type, you can run into problems. Let's look at some examples to understand what happens:


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

int main() {
  // A really big number
  long long BigNumber{12345678901234};

  // Try to convert it to a regular int
  int SmallNumber{static_cast<int>(BigNumber)};  //<w>

  cout << "Original number: " << BigNumber;
  cout << "\nConverted number: " << SmallNumber;
}
```


```c++
//<o>
Original number: 12345678901234
Converted number: 1942892530
```


When you run this program, you might get unexpected results - the number might be completely different from what you put in! This is called **overflow**, and it happens because different number types can hold different ranges of values.


Here's another example with decimal numbers:


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

int main() {
  // A float can't hold as many decimal places
  // as a double
  double Precise{123456789.123456789};
  float LessPrecise{static_cast<float>(Precise)};  //<w>

  // Show more decimal places
  cout.precision(12);
  cout << "Original number: " << Precise;
  cout << "\nConverted number: " << LessPrecise;
}
```


```plain text
//<o>
Original number: 123456789.123
Converted number: 123456792
```


Notice how we lost some precision in the decimal places! This is because `float` can't store as many digits as `double`.


To avoid these problems, you should:

- Use types that are big enough for your numbers
- Test your conversions with the actual values you'll be using
- Use uniform initialization with `{ }` instead of `=` when possible, as it will warn you about dangerous conversions
- Consider whether you really need to convert between types at all

Remember: just because C++ lets you convert between types doesn't always mean you should!

Converting Large Numbers

This is a really interesting question that goes back to how computers fundamentally work with true and false values. Let's break it down:


## The Historical Reason


In early computers, there was no special boolean type - programmers used regular numbers to represent true and false. They needed a consistent rule for which numbers meant true and which meant false. The simplest rule was:

- `0` means `false` (nothing, absence of a value)
- Any other number means `true` (presence of a value)

This tradition carried forward into C, and then into C++, even after C++ added the `bool` type.


## Why This Makes Sense


This convention actually turns out to be really useful in practice. Here's an example:


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

int main() {
  int PlayerHealth{100};

  // We can use PlayerHealth directly in an
  // if statement
  if (PlayerHealth) {
    cout << "Player is alive!\n";
  }

  // Later in the game, player takes damage...
  PlayerHealth = 0;

  if (PlayerHealth) {
    cout << "Player is alive!";
  } else {
    cout << "Game Over!";
  }
}
```


```plain text
//<o>
Player is alive!
Game Over!
```


In this example, we can check if the player is alive just by checking if their health is non-zero. We don't need to write `if (PlayerHealth > 0)` - though that would work too!


## Real World Examples


This pattern shows up in many real-world programming scenarios:

- Checking if we found something (0 means not found)
- Checking if a calculation succeeded (0 means failed)
- Checking if a player has any resources left (0 means empty)
- Checking if an error occurred (0 means no error)

The pattern is so useful that many modern programming languages have adopted it, even ones that weren't based on C or C++.

Numbers as Booleans

Let's look at how implicit conversions affect your program's performance. While this might seem like a complex topic, we can break it down into simple parts.


## Basic Rule


The simple answer is: yes, conversions can be slower than using exact types, but usually not enough to worry about in most situations.  Here's a simple example:


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

int main() {
  // No conversion needed - fast!
  int DirectInt{42};

  // Needs conversion - slightly slower
  int ConvertedInt = 42.0;  //<w>

  // Using these variables so the compiler
  // doesn't optimize them away
  cout << "Direct: " << DirectInt << "\n";
  cout << "Converted: " << ConvertedInt;
}
```


```c++
//<o>
Direct: 42
Converted: 42
```


## Why Conversions Take Time


When the computer converts between types, it needs to do extra work:

- Converting a `float` to an `int` needs to remove the decimal part
- Converting a small number type to a bigger one needs to add extra digits
- Converting between `bool` and numbers needs to check if the value is zero

Think of it like converting between currencies. If you're paying in dollars at a store that only accepts euros, the cashier needs to do some math to convert the amount. This takes a little extra time compared to just accepting the euros directly.


## When Should You Care?


For most programs, especially when you're learning C++, the speed difference is so tiny you won't notice it. You should focus on:

- Writing clear, easy-to-understand code
- Using the types that make sense for your data
- Avoiding dangerous conversions that might lose information

Only worry about the performance of conversions if:

- You're doing the conversion millions of times
- The conversion is in a critical part of your program that needs to be super fast
- You've measured your program and found that conversions are actually causing a problem

Remember: Code that's clear and correct is better than code that's fast but confusing or buggy!

Performance Impact

While it might seem safer to require exact types everywhere, implicit conversions actually make programming more practical and convenient. Let's look at why we have them:


## Making Numbers Work Like Real Math


In math class, we freely mix different types of numbers. We can add whole numbers and decimals without thinking about it:


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

int main() {
  // In math: 5 + 3.14 is perfectly normal
  float Sum{5 + 3.14f};
  cout << "5 + 3.14 = " << Sum << "\n";

  // We often mix whole numbers and decimals
  // Starting position
  float PlayerX{10};         
  // Move half a unit right
  PlayerX = PlayerX + 0.5f;  
  cout << "Player position: " << PlayerX;
}
```


```plain text
//<o>
5 + 3.14 = 8.14
Player position: 10.5
```


Without implicit conversions, we'd have to write extra code to convert numbers every time we mix types:


```c++
int main() {
  // Without implicit conversions, we'd need
  // explicit conversions everywhere
  float Sum{static_cast<float>(5) + 3.14f};  //<w>
  float PlayerX{static_cast<float>(10)};  //<w>
}
```


## Making Common Operations Simpler


Implicit conversions help with everyday programming tasks. For example, checking if a number is non-zero:


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

int main() {
  int Score{100};

  // This is clear and simple
  if (Score) {
    cout << "Player has points!\n";
  }

  // Without implicit conversions, we'd need:
  if (Score > 0) {
    cout << "This is more complicated than"
      " needed!";
  }
}
```


```c++
//<o>
Player has points!
This is more complicated than needed!
```


## Safe vs Unsafe Conversions


C++ does try to protect us from dangerous conversions. Remember how using `{ }` for initialization prevents narrowing:


```c++
int main() {
  // This could lose data - C++ prevents it
  int DangerousInt{3.14f};  //<e>

  // We have to be explicit if we really want to do this
  int IntentionalInt{static_cast<int>(3.14f)};
}
```


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


So C++ gives us the best of both worlds:

- Convenient implicit conversions for safe operations
- Protection against accidental data loss
- The ability to be explicit when we need to be

Purpose of Implicit Conversions

Yes! There are several ways to make your code more strict about type conversions. Let's look at the main approaches:


## Using Uniform Initialization


The simplest way to catch many unwanted conversions is to always use `{ }` for initialization instead of `=`:


```c++
int main() {
  // These dangerous conversions are caught:
  int MyInt{3.14};  //<e>

  // Compiles but loses data:
  int UnsafeInt = 3.14;  //<w>
}
```


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


## Using Compiler Warnings


Modern C++ compilers can warn you about implicit conversions. Here's how they help:


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

int main() {
  double Pi{3.14159};

  // The compiler will warn about these:
  int RoundedPi = Pi;   //<w>
  bool IsPositive = Pi; //<w>

  cout << RoundedPi << "\n";
  cout << std::boolalpha << IsPositive;
}
```


```c++
//<o>
3
true
```


Most compilers will show warnings for these lines, helping you catch potential problems.


## Using explicit Casts


When you do need to convert between types, you can make your intentions clear using `static_cast<>()`:


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

int main() {
  double Pi{3.14159};

  // These make our intentions clear:
  int RoundedPi{static_cast<int>(Pi)};
  bool IsPositive{static_cast<bool>(Pi)};

  cout << "Rounded: " << RoundedPi << "\n";
  cout << "Is Positive: " << std::boolalpha
    << IsPositive;
}
```


```plain text
//<o>
Rounded: 3
Is Positive: true
```


## Good Practices for Preventing Unwanted Conversions


Here are some tips to help prevent unwanted conversions:

- Always use uniform initialization with `{ }`
- Enable compiler warnings (your IDE probably has these on by default)
- Use `static_cast<>()` when you really need to convert types
- Review compiler warnings regularly - don't ignore them!
- Pick the right types for your data from the start

Disabling Implicit Conversions

Different programming languages handle type conversions in their own ways. Let's look at how C++'s approach compares to other languages you might learn later:


## C++ vs Python


In C++, we typically need to be more explicit with our types and conversions:


```c++
#include <string>

int main() {
  std::string Text{"123"};
  int Number{static_cast<int>(std::stoi(Text))};
}
```


Python is very flexible with conversions:


```python
number = int("123")  # Python converts strings automatically
```


## C++ vs Java


Java is stricter than C++ in some ways:


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

int main() {
  // C++ allows this implicit conversion
  int WholeNumber{42};

  // This works in C++
  double Decimal = WholeNumber;

  // Java would require:
  // double decimal = (double)wholeNumber;

  // But C++ is more permissive with booleans
  int Value{100};
  if (Value) { // This works in C++, not in Java //<h>
    cout << "C++ treats non-zero as true";
  }
}
```


## Why C++ is Different


C++ gives you more control but requires more care:

- It allows many implicit conversions for convenience
- It warns you about dangerous conversions (with uniform initialization)
- It lets you be explicit when needed (with `static_cast<>()`)
- It trusts you to know what you're doing (sometimes too much!)

This approach fits C++'s philosophy of giving programmers power and control, while trying to help prevent mistakes where possible.


Remember:

- Use uniform initialization `{ }` to catch dangerous conversions
- Be explicit with `static_cast<>()` when converting types
- Consider whether you really need the conversion at all

Language Comparison

Understanding how conversions affect memory usage is important, especially in games where performance matters. Let's break this down:


## Converting to Bigger Types


When you convert a smaller type to a bigger type, you use more memory:


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

int main() {
  // Small number types
  char SmallNumber{65};          // Uses 1 byte
  int BiggerNumber{SmallNumber}; // Uses 4 bytes

  // The computer needs extra memory to
  // store the same value!
  cout << "Original char: " << SmallNumber;
  cout << "\nAs integer: " << BiggerNumber;
}
```


```plain text
//<o>
Original char: A
As integer: 65
```


## Converting to Smaller Types


Going the other way can save memory but might lose information:


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

int main() {
  // Big number type - uses 8 bytes
  double BigDecimal{3.14159265359};

  // Uses 4 bytes
  float SmallDecimal{
    static_cast<float>(BigDecimal)};

  cout.precision(10);
  cout << "Original:  " << BigDecimal << "\n";
  cout << "Converted: " << SmallDecimal;
}
```


```plain text
//<o>
Original:  3.141592654
Converted: 3.141592741
```


## Memory Usage Guidelines


Here's what to remember about conversions and memory.


**Converting to bigger types:**

- Always safe - no data loss
- Uses more memory
- Might be slightly slower

**Converting to smaller types:**

- Might lose data
- Uses less memory
- Usually not worth the risk just to save memory

**Most of the time, you should:**

1. Choose the right type for your data from the start
2. Don't convert just to save memory unless you're sure you need to
3. Use uniform initialization to catch accidental conversions that might lose data

Memory Usage

<Excerpt>


In our journey so far, we have discovered how functions and variables work with specific data types. Each type, like `int` or `float`, plays a unique role.  But what happens when we mix these types - for example, what happens when we use an `int` where a `float` is expected?


This scenario introduces us to the concept of **implicit conversion**.


It allows us to use different types of values interchangeably in some situations, without needing to manually convert them. For instance, it lets us provide an `int` value where a `float` is expected. The compiler, our code's translator, handles this conversion for us.


However, there's a twist. Not all conversions are equal. Some are straightforward, like turning an `int` into a `float`. Others, like converting a `string` to an `int`, are not possible implicitly.


In this lesson, we'll explore how implicit conversions work with variables, functions, and operators. We'll also tackle the concept of _**narrowing casts**_, a special type of conversion that needs extra attention.


</Excerpt>


## Implicit Conversions with Variables


Data types in C++ can allow values of their type to be created from a value of a different type.  We'll see how to give our custom data types this ability in a later chapter.


For now, we'll focus on the built-in types.  We've already seen these implicit conversions in action when working with numbers.  For example, we've been able to create a `float` from an `int`:


```c++
float MyNumber { 5 }; // 5.0
```


This works, because the `float` data type includes the ability to create one of its objects (eg, `5.0`) using an object of the `int` type (eg, `5`)


This is not always possible.  For example, the `float` data type cannot create objects from a `string`.  Let's try:


```c++
string MyString { "Hello" };
float MyNumber { MyString };//<e>
```


This fails with an error message similar to:


```c++
//<oe>
No viable conversion from std::string to float
```


## Implicit Conversions with Functions


Just like with variables, C++ can automatically convert values when they're returned from functions. While it's best practice to return the exact type a function declares, the compiler will perform implicit conversions when necessary.


Here are some examples of implicit conversions with function returns:


```c++
// Converting 0 to a boolean results in false
bool IsDeadFrom0() {
  return 0;  // false//<w>
}

// Converting a non-0 integer to a
// boolean results in true
bool IsDeadFrom42() {
  return 42; // true//<w>
}

// Converting false to an integer results in 0
int LevelFromFalse() {
  return false; // 0//<w>
}

// Converting true to an integer results in 1
int LevelFromTrue() {
  return true; // 1//<w>
}

// Conversions can happen multiple times
// This function will convert 50 to true...
bool GetHealth() {
  return 50;//<w>
}

// This variable initialization converts true to 1
int Health { GetHealth() }; // Health will be 1//<w>
```


While C++ allows these conversions, it's better to return the exact type your function declares. This makes your code clearer and helps prevent unexpected behavior.


## Implicit Conversions with Operators


Behind the scenes, operators are very similar to functions.  We'll see examples of this later in the course, where we learn how to create our own operators.


Because of this similarity with functions, operators also implement implicit conversions in the same way as values returned from functions:


```c++
// This will result in 6
int Level { 5 + true };//<w>
```


<Ad />


## Narrowing Casts


Implicit casts are quite contentious.  Many argue that programming languages shouldn't do them at all, because they're a source of errors and confusion.


We may, for example, write code like the following.  Note, we're using the `=` syntax to initialize this variable, rather than the `{ }` syntax we typically prefer:


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

int main() {
  int Pi = 3.14; //<w>
}
```


Our intent here is almost certainly to initialize `Pi` to `3.14` but because we accidentally set the type to `int` rather than `float`, we'll be using `3`.


The compiler will allow this, and we may not even notice that our calculations are less accurate than we intended.  This is an example of a **narrowing cast**.


Narrowing casts are operations where converting one data type to another could cause loss of data. For example, storing `3.14` as an `int` would cause the `.14` component to be lost, leaving us with only `3`.


<Aside>


### Compiler Warnings


Even though the C++ specification does allow narrowing casts at variable initialization using the `=` syntax, compilers will often detect this issue and output a _**warning**_.


Unlike a compiler error, a compiler warning will not prevent our code from compiling.  Instead, it lets the compiler draw our attention to scenarios where our code might be technically valid, but seems unusual or potentially dangerous.


IDEs will typically present compiler warnings somewhere on their UI after our program compiles.  In Visual Studio, we can see warnings by expanding the _**View**_ menu from the top menu bar, and selecting _**Error List**_


<Img file="compiler-warnings-narrow.png" width="671" height="185" alt="Screenshot of Visual Studio outputting compiler warnings" blurHash="L25}pz%Mk6kS_4jvoubZ4nM{bGay" />


</Aside>


### Uniform Initialisation Prevents Narrowing Casts


One advantage of Uniform Initialisation using `{` and `}` is that it protects us against this.


If we update our previous example to use uniform initialization instead of `=`, the compiler will fail and alert us to the issue.  This is better than letting a potential bug slip through:


```c++
int Pi = 3.14;//<d>
int Pi { 3.14 };//<e>
```


Our compiler will now output an error instead of a warning:


```c++
//<oe>
Error: conversion from 'double' to 'int' requires a narrowing conversion
```


Here are some slightly more complex examples:


```c++
float GetPiFloat() { return 3.14; }
double GetPiDouble() { return 3.14; }

// Converting a float to an int will fail
int A{GetPiFloat()};//<e>

// Converting a double to an int will fail
int B{GetPiDouble()};//<e>

// Converting a double to a float will fail
float C{GetPiDouble()};//<e>

// But converting a float to a double is fine
// Any float can be converted to a double
// without data loss
double D{GetPiFloat()};//<h>
```


<Aside>


### But Haven't We Been Narrowing Doubles This Whole Time?


In an earlier lesson, when talking about literals, we pointed out that an expression like `4.0` is a `double`, rather than a `float`.


We've also seen how a statement like the following is valid:


```c++
float MyNumber { 4.0 };
```


This may seem to conflict with what we just read.  Isn't that code narrowing a `double` to a `float`?


The reason the above code works is that the compiler can determine at build time if the double `4.0` can be stored as the float `4.0f` without data loss.  It can, so the compiler allows it.


`4.0` is an example of a _**constant expression,**_ that is, something that can be evaluated at compile time. We have a dedicated lesson on this coming later in this course.


If our narrowing cast was using a typical variable or the value returned by a typical function, it would no longer be a constant expression that can be evaluted at compile time.  Because of this, the compiler can no longer reliably determine if narrowing that specific `double` will lose data, so it will play it safe and just output an error:


```c++
double MyDouble { 4.0 };
float MyFloat { MyDouble };//<e>
```


After this small change, we get the same narrowing cast error we described in this section:


```c++
//<oe>
error: non-constant-expression cannot be narrowed from type `double` to `float`
```


</Aside>


It is, of course, possible to do conversions that result in data loss, like converting an `int` to a `bool`.  Uniform initialization just prevents it from being done automatically, because there's a risk we won't notice it's happening.


In those scenarios, the compiler would rather we be _**explicit**_ in our intentions. We'll learn how to do explicit conversions soon.


## Summary


In this lesson, we explored the concepts of implicit conversions and narrowing casts. Here's what we covered:

- **Implicit Conversions**: Understanding how C++ automatically converts one data type to another when needed, such as converting an `int` to a `float`.
- **Implicit Conversions with Variables and Functions**: Seeing how built-in data types allow creation from different types, and applying this knowledge to functions and operators.
- **Narrowing Casts**: Learning about conversions that can lead to data loss, like converting a `double` to an `int`.
- **Uniform Initialization**: Exploring how this syntax helps prevent unintentional narrowing casts, preventing potential bugs.

We hope this lesson has shed light on how implicit conversions and narrowing casts work in C++, enhancing your understanding of the language's versatility and potential pitfalls.


<Preview>


### Function Arguments and Parameters


As we wrap up our exploration of implicit conversions and narrowing casts, we set our sights on the next topic: **Function Arguments and Parameters**. Here's what we'll cover:

- **Defining Functions with Parameters**: Learn how to create functions that can take inputs, allowing for more dynamic and reusable code.
- **Passing Arguments**: Understand how to pass data to functions, exploring the relationship between arguments and parameters.
- **Different Types of Parameters**: Discover the various ways to define parameters in functions.
- **Understanding Default Values**: Learn what default parameters are and why they're useful in function definitions.

</Preview>

Improved presentation of error output sections

Type conversions and type safety

Implicit conversions

C++ Core Guidelines: Rules for Conversions and Casts

{CPP}A comprehensive overview of implicit conversions and narrowing casts for beginners

{CPP}Implicit Conversions and Narrowing Casts in C++

Uniform Initialisation Prevents Narrowing Casts

But Haven't We Been Narrowing Doubles This Whole Time?

Implicit Conversions and Narrowing Casts

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Intro to C++ Programming

Questions & Answers