Implicit Conversions and Narrowing Casts

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:

1float 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:

1string MyString { "Hello" };
2float MyNumber { MyString };

This fails with an error message similar to:

1No viable conversion from std::string to float

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, C++ will perform implicit conversions when necessary.

Here are some examples of implicit conversions with function returns:

1// Converting 0 to a boolean results in false
2bool IsDeadFrom0() {
3  return 0;  // false
4}
5
6// Converting a non-0 integer to a
7// boolean results in true
8bool IsDeadFrom42() {
9  return 42; // true
10}
11
12// Converting false to an integer results in 0
13int LevelFromFalse() {
14  return false; // 0
15}
16
17// Converting true to an integer results in 1
18int LevelFromTrue() {
19  return true; // 1
20}
21
22// Conversions can happen multiple times
23// This function will convert 50 to true...
24bool GetHealth() {
25  return 50;
26}
27
28// This variable initialization
29// converts true to 1
30int Health { GetHealth() }; // Health will be 1

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.

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

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

1// This will result in 6
2int Level { 5 + true };

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:

1#include <iostream>
2using namespace std;
3
4int main() {
5  int Pi = 3.14; 
6}

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.

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, the compiler will fail and alert us to the issue. This is better than letting a potential bug slip through:

1int Pi { 3.14 };

Our compiler will tell us where the problem is, with an error:

1Error: conversion from 'double' to 'int' requires a narrowing conversion

Here are some slightly more complex examples:

1float GetPiFloat() { return 3.14; }
2double GetPiDouble() { return 3.14; }
3
4// Converting a float to an int will fail
5int A{GetPiFloat()};
6
7// Converting a double to an int will fail
8int B{GetPiDouble()};
9
10// Converting a double to a float will fail
11float C{GetPiDouble()};
12
13// But converting a float to a double is fine
14// Any float can be converted to a double
15// without data loss
16double D{GetPiFloat()};

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.

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.