Disabling Implicit Conversions

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

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

1int main() {
2  // These dangerous conversions are caught:
3  int MyInt{3.14};  
4
5  // Compiles but loses data:
6  int UnsafeInt = 3.14;  
7}

1error C2397: conversion from 'double' to 'int' requires a narrowing conversion

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

1#include <iostream>
2using namespace std;
3
4int main() {
5  double Pi{3.14159};
6
7  // The compiler will warn about these:
8  int RoundedPi = Pi;   
9  bool IsPositive = Pi; 
10
11  cout << RoundedPi << "\n";
12  cout << std::boolalpha << IsPositive;
13}

13
2true

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

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

1#include <iostream>
2using namespace std;
3
4int main() {
5  double Pi{3.14159};
6
7  // These make our intentions clear:
8  int RoundedPi{static_cast<int>(Pi)};
9  bool IsPositive{static_cast<bool>(Pi)};
10
11  cout << "Rounded: " << RoundedPi << "\n";
12  cout << "Is Positive: " << std::boolalpha
13    << IsPositive;
14}

1Rounded: 3
2Is Positive: true

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