Implicit Conversions and Narrowing Casts

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, using an int value where a float is needed. 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.

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:

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

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

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 implement our custom operators.

Because of this, operators also implement implicit conversions in the same way we covered above:

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

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

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

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

1float MyNumber { 4.0 };

1double MyDouble { 4.0 };
2float MyFloat { MyDouble };

1error: non-constant-expression cannot be narrowed from type `double` to `float`

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.

The compiler would rather we be explicit in our intentions. We'll be introduced to explicit casting soon.

Summary

In this lesson, we delved into 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 of Next Lesson

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 a sneak peek of what we'll dive into:

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

Next Lesson

Function Arguments and Parameters

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

ContinueView Course