Disabling Implicit Conversions

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

Using Uniform Initialization

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

Using Compiler Warnings

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.

Using explicit Casts

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

Good Practices for Preventing Unwanted Conversions

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