Implicit Conversions in C++

We've seen that if our functions specify a return type, they always need to return something. This includes returning something from every conditional branch, if we are using them.

However, our functions don't necessarily need to return something of the correct type - just something that can be converted to the correct type. In many cases, this conversion will be done for us automatically, by a process known as implicit conversion.

We could write code to do it - we'll see how to do explicit conversions soon. But so far, we've just been using something of type X (eg, an int) as if it were something of type Y (eg a float) and letting the compiler figure it out

Implicit Conversions with Variables

Data types in C++ can have special functions that allow values of that type to convert themselves to other data types. 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. In fact, 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
2

This works, because the integer data type includes a special function that implemented the logic to convert one of its objects (eg, 5) to an object of the float type (eg, 5.0)

This is not always possible. For example, the strings data type does not have the ability to convert its objects to floats.

Lets try:

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

This fails with an error message similar to:

1No viable conversion from `std::string` to `float`
2

Implicit Conversions with Functions

Implicit conversions apply to our function return types too. We should generally try to return the correct type, but it's not always necessary.

We should, of course, strive not to write code like this, but these are all acceptable C++ functions:

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 boolean results in true
7bool IsDeadFrom42() {
8  return 42; // true
9}
10
11// Converting false to an integer results in 0
12int LevelFromFalse() {
13  return false; // 0
14}
15
16// Converting true to an integer results in 1
17int LevelFromTrue() {
18  return true; // 1
19}
20
21// Conversions can happen multiple times
22// This function will convert 50 to true...
23bool GetHealth() {
24  return 50;
25}
26
27// ...and this variable initialisation converts true to 1
28int Health { GetHealth() }; // Health will be 1
29
30// Operators also behave like functions
31// This will result in 6
32int Level { 5 + true };
33

C++ 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:

1int pi = 3.14;
2float Circumference(float radius) {
3  return 2 * pi * radius;
4}
5

Our intent here is clearly to set pi to 3.14 but because we accidentally set the type to int rather than float, we'll actually be using 3.

The compiler will allow this, and we may not even notice that our calculations are 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.

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

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

1int pi { 3.14 };
2float Circumference(float radius) {
3  return 2 * radius * pi;
4}
5

Our compiler will tell us where the problem is, with error that will state something like "type double cannot be narrowed to int"

Here are some more examples:

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

1float MyNumber { 4.0 };
2

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

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

It is, of course, possible to do conversions that result in data loss, like converting an int to a bool. Uniform initialisation 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.

Up next, we will add the final big piece to our initial exploration of functions. Arguments allow our functions to be even more dynamic and powerful.