Why do we need implicit conversions at all? Wouldn't it be safer to always require exact types?

Question

Ryan McCombe · Accepted Answer

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:

1#include <iostream>
2using namespace std;
3
4int main() {
5  // In math: 5 + 3.14 is perfectly normal
6  float Sum{5 + 3.14f};
7  cout << "5 + 3.14 = " << Sum << "\n";
8
9  // We often mix whole numbers and decimals
10  // Starting position
11  float PlayerX{10};         
12  // Move half a unit right
13  PlayerX = PlayerX + 0.5f;  
14  cout << "Player position: " << PlayerX;
15}

15 + 3.14 = 8.14
2Player position: 10.5

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

1int main() {
2  // Without implicit conversions, we'd need
3  // explicit conversions everywhere
4  float Sum{static_cast<float>(5) + 3.14f};  
5  float PlayerX{static_cast<float>(10)};  
6}

Making Common Operations Simpler

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

1#include <iostream>
2using namespace std;
3
4int main() {
5  int Score{100};
6
7  // This is clear and simple
8  if (Score) {
9    cout << "Player has points!\n";
10  }
11
12  // Without implicit conversions, we'd need:
13  if (Score > 0) {
14    cout << "This is more complicated than"
15      " needed!";
16  }
17}

1Player has points!
2This 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:

1int main() {
2  // This could lose data - C++ prevents it
3  int DangerousInt{3.14f};  
4
5  // We have to be explicit if we really want to do this
6  int IntentionalInt{static_cast<int>(3.14f)};
7}

1error 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

Implicit Conversions and Narrowing Casts

Purpose of Implicit Conversions

Making Numbers Work Like Real Math

Making Common Operations Simpler

Safe vs Unsafe Conversions

Implicit Conversions and Narrowing Casts

Intro to C++ Programming

Questions & Answers